gfgfgf

.env

@@ -11,50 +11,104 @@ ENVIAR1_ATIVO=n
 ENVIAR1_INTERVALO_MINUTOS=1
 ENVIAR1_ARQUIVO_ORDENS=ordens1.json
 ENVIAR1_QUANTIDADE_ORDENS=2
+ENVIAR1_HORA_INICIO=08:00
+ENVIAR1_HORA_FIM=22:00
 
 # ═══ Envio Automático 2 ═════════════════════════════════════════════
 ENVIAR2_ATIVO=n
 ENVIAR2_INTERVALO_MINUTOS=1
 ENVIAR2_ARQUIVO_ORDENS=ordens2.json
 ENVIAR2_QUANTIDADE_ORDENS=2
+ENVIAR2_HORA_INICIO=08:00
+ENVIAR2_HORA_FIM=22:00
 
 # ═══ Envio Automático 3 ═════════════════════════════════════════════
 ENVIAR3_ATIVO=n
 ENVIAR3_INTERVALO_MINUTOS=1
 ENVIAR3_ARQUIVO_ORDENS=ordens3.json
 ENVIAR3_QUANTIDADE_ORDENS=2
+ENVIAR3_HORA_INICIO=08:00
+ENVIAR3_HORA_FIM=22:00
 
 # ═══ Envio Automático 4 ═════════════════════════════════════════════
 ENVIAR4_ATIVO=n
 ENVIAR4_INTERVALO_MINUTOS=10
 ENVIAR4_ARQUIVO_ORDENS=ordens4.json
 ENVIAR4_QUANTIDADE_ORDENS=2
+ENVIAR4_HORA_INICIO=08:00
+ENVIAR4_HORA_FIM=22:00
 
 # ═══ Envio Automático 5 ═════════════════════════════════════════════
 ENVIAR5_ATIVO=n
 ENVIAR5_INTERVALO_MINUTOS=1
 ENVIAR5_ARQUIVO_ORDENS=ordens5.json
 ENVIAR5_QUANTIDADE_ORDENS=2
+ENVIAR5_HORA_INICIO=08:00
+ENVIAR5_HORA_FIM=22:00
 
 # ═══ Envio Automático 6 ═════════════════════════════════════════════
 ENVIAR6_ATIVO=n
 ENVIAR6_INTERVALO_MINUTOS=1
 ENVIAR6_ARQUIVO_ORDENS=ordens6.json
 ENVIAR6_QUANTIDADE_ORDENS=2
+ENVIAR6_HORA_INICIO=08:00
+ENVIAR6_HORA_FIM=22:00
 
 # ═══ Envio Automático 7 ═════════════════════════════════════════════
 ENVIAR7_ATIVO=n
 ENVIAR7_INTERVALO_MINUTOS=1
 ENVIAR7_ARQUIVO_ORDENS=ordens7.json
 ENVIAR7_QUANTIDADE_ORDENS=2
+ENVIAR7_HORA_INICIO=08:00
+ENVIAR7_HORA_FIM=22:00
 
 # ═══ Envio Automático 8 ═════════════════════════════════════════════
-ENVIAR8_ATIVO=s
+ENVIAR8_ATIVO=n
 ENVIAR8_INTERVALO_MINUTOS=1
 ENVIAR8_ARQUIVO_ORDENS=ordens8.json
 ENVIAR8_QUANTIDADE_ORDENS=2
+ENVIAR8_HORA_INICIO=08:00
+ENVIAR8_HORA_FIM=22:00
 
-# ═══ Horário de funcionamento (formato HH:MM, 24h) ═══════════════════
+# ═══ Envio Automático 9 ═════════════════════════════════════════════
-HORA_INICIO=08:00
+ENVIAR9_ATIVO=n
-HORA_FIM=22:00
+ENVIAR9_INTERVALO_MINUTOS=1
+ENVIAR9_ARQUIVO_ORDENS=ordens9.json
+ENVIAR9_QUANTIDADE_ORDENS=1
+ENVIAR9_HORA_INICIO=08:00
+ENVIAR9_HORA_FIM=22:00
+
+# ═══ Envio Automático 10 ════════════════════════════════════════════
+ENVIAR10_ATIVO=n
+ENVIAR10_INTERVALO_MINUTOS=1
+ENVIAR10_ARQUIVO_ORDENS=ordens10.json
+ENVIAR10_QUANTIDADE_ORDENS=1
+ENVIAR10_HORA_INICIO=08:00
+ENVIAR10_HORA_FIM=22:00
+
+# ═══ Envio Automático 11 — IA ═══════════════════════════════════════
+ENVIAR11_ATIVO=s
+ENVIAR11_IA=s
+ENVIAR11_INTERVALO_MINUTOS=120
+ENVIAR11_ARQUIVO_ORDENS=prompt_ia.json
+ENVIAR11_QUANTIDADE_ORDENS=1
+ENVIAR11_HORA_INICIO=08:00
+ENVIAR11_HORA_FIM=22:00
+
+# ═══ Envio Automático 12 ════════════════════════════════════════════
+ENVIAR12_ATIVO=s
+ENVIAR12_INTERVALO_MINUTOS=50
+ENVIAR12_ARQUIVO_ORDENS=ordens12.json
+ENVIAR12_QUANTIDADE_ORDENS=1
+ENVIAR12_HORA_INICIO=07:00
+ENVIAR12_HORA_FIM=17:00
+
+# OpenRouter AI
+OPENROUTER_API_KEY=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
+#OPENROUTER_MODEL=cognitivecomputations/dolphin-mistral-24b-venice-edition
+OPENROUTER_MODEL=thedrummer/cydonia-24b-v4.1
+OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
+OPENROUTER_TIMEOUT=60
+OPENROUTER_MAX_TOKENS=8192
+OPENROUTER_MAX_LINHAS=7
 

.env.example

@@ -17,49 +17,107 @@ ENVIAR1_INTERVALO_MINUTOS=1
 ENVIAR1_ARQUIVO_ORDENS=ordens1.json
 # Quantidade de ordens enviadas POR CICLO (1 = uma por ciclo, 3 = três de uma vez a cada intervalo)
 ENVIAR1_QUANTIDADE_ORDENS=1
+# Horário específico deste envio (HH:MM, 24h)
+# ENVIAR1_HORA_INICIO=08:00
+# ENVIAR1_HORA_FIM=22:00
 
 # ═══ Envio Automático 2 ═════════════════════════════════════════════
 ENVIAR2_ATIVO=s
 ENVIAR2_INTERVALO_MINUTOS=1
 ENVIAR2_ARQUIVO_ORDENS=ordens2.json
 ENVIAR2_QUANTIDADE_ORDENS=1
+# ENVIAR2_HORA_INICIO=08:00
+# ENVIAR2_HORA_FIM=22:00
 
 # ═══ Envio Automático 3 ═════════════════════════════════════════════
 ENVIAR3_ATIVO=s
 ENVIAR3_INTERVALO_MINUTOS=1
 ENVIAR3_ARQUIVO_ORDENS=ordens3.json
 ENVIAR3_QUANTIDADE_ORDENS=1
+# ENVIAR3_HORA_INICIO=08:00
+# ENVIAR3_HORA_FIM=22:00
 
 # ═══ Envio Automático 4 ═════════════════════════════════════════════
 ENVIAR4_ATIVO=s
 ENVIAR4_INTERVALO_MINUTOS=1
 ENVIAR4_ARQUIVO_ORDENS=ordens4.json
 ENVIAR4_QUANTIDADE_ORDENS=1
+# ENVIAR4_HORA_INICIO=08:00
+# ENVIAR4_HORA_FIM=22:00
 
 # ═══ Envio Automático 5 ═════════════════════════════════════════════
 ENVIAR5_ATIVO=s
 ENVIAR5_INTERVALO_MINUTOS=1
 ENVIAR5_ARQUIVO_ORDENS=ordens5.json
 ENVIAR5_QUANTIDADE_ORDENS=1
+# ENVIAR5_HORA_INICIO=08:00
+# ENVIAR5_HORA_FIM=22:00
 
 # ═══ Envio Automático 6 ═════════════════════════════════════════════
 ENVIAR6_ATIVO=s
 ENVIAR6_INTERVALO_MINUTOS=1
 ENVIAR6_ARQUIVO_ORDENS=ordens6.json
 ENVIAR6_QUANTIDADE_ORDENS=1
+# ENVIAR6_HORA_INICIO=08:00
+# ENVIAR6_HORA_FIM=22:00
 
 # ═══ Envio Automático 7 ═════════════════════════════════════════════
 ENVIAR7_ATIVO=s
 ENVIAR7_INTERVALO_MINUTOS=1
 ENVIAR7_ARQUIVO_ORDENS=ordens7.json
 ENVIAR7_QUANTIDADE_ORDENS=1
+# ENVIAR7_HORA_INICIO=08:00
+# ENVIAR7_HORA_FIM=22:00
 
 # ═══ Envio Automático 8 ═════════════════════════════════════════════
 ENVIAR8_ATIVO=s
 ENVIAR8_INTERVALO_MINUTOS=1
 ENVIAR8_ARQUIVO_ORDENS=ordens8.json
 ENVIAR8_QUANTIDADE_ORDENS=1
+# ENVIAR8_HORA_INICIO=08:00
+# ENVIAR8_HORA_FIM=22:00
 
-# ═══ Horário de funcionamento (formato HH:MM, 24h) ═══════════════════
+# ═══ Envio Automático 9 ═════════════════════════════════════════════
-HORA_INICIO=08:00
+ENVIAR9_ATIVO=s
-HORA_FIM=22:00
+ENVIAR9_INTERVALO_MINUTOS=1
+ENVIAR9_ARQUIVO_ORDENS=ordens9.json
+ENVIAR9_QUANTIDADE_ORDENS=1
+# ENVIAR9_HORA_INICIO=08:00
+# ENVIAR9_HORA_FIM=22:00
+
+# ═══ Envio Automático 10 ════════════════════════════════════════════
+ENVIAR10_ATIVO=s
+ENVIAR10_INTERVALO_MINUTOS=1
+ENVIAR10_ARQUIVO_ORDENS=ordens10.json
+ENVIAR10_QUANTIDADE_ORDENS=1
+# ENVIAR10_HORA_INICIO=08:00
+# ENVIAR10_HORA_FIM=22:00
+
+# ═══ Envio Automático 11 — IA (geração via OpenRouter) ═════════════
+# ENVIAR11_IA=s      ← 's' ativa o modo IA; usa PROMPT_IA_ARQUIVO como prompt base
+ENVIAR11_ATIVO=n
+ENVIAR11_IA=n
+ENVIAR11_INTERVALO_MINUTOS=5
+# O ARQUIVO_ORDENS aqui é apenas o prompt base enviado à IA (não é uma lista de ordens)
+ENVIAR11_ARQUIVO_ORDENS=prompt_ia.json
+ENVIAR11_QUANTIDADE_ORDENS=1
+# ENVIAR11_HORA_INICIO=08:00
+# ENVIAR11_HORA_FIM=22:00
+
+# ═══ Envio Automático 12 ════════════════════════════════════════════
+ENVIAR12_ATIVO=n
+ENVIAR12_INTERVALO_MINUTOS=5
+ENVIAR12_ARQUIVO_ORDENS=ordens12.json
+ENVIAR12_QUANTIDADE_ORDENS=1
+# ENVIAR12_HORA_INICIO=08:00
+# ENVIAR12_HORA_FIM=22:00
+
+# ═══ OpenRouter AI ═══════════════════════════════════════════════════
+OPENROUTER_API_KEY=sua_chave_aqui
+OPENROUTER_MODEL=deepseek/deepseek-v4.1-flash
+OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
+OPENROUTER_TIMEOUT=60
+# Tamanho máximo da resposta da IA em tokens (padrão: 2048)
+OPENROUTER_MAX_TOKENS=2048
+# Máximo de linhas da resposta da IA (0 = sem limite)
+OPENROUTER_MAX_LINHAS=15

README.md

@@ -4,7 +4,7 @@ Bot do Telegram que envia ordens eróticas automáticas em intervalos configurá
 
 ## Funcionalidades
 
-- **Múltiplos envios automáticos** — até 8 canais independentes rodando em paralelo (`ENVIAR1` a `ENVIAR8`), cada um com seu próprio arquivo de ordens, intervalo e quantidade por ciclo.
+- **Múltiplos envios automáticos** — até 10 canais independentes rodando em paralelo (`ENVIAR1` a `ENVIAR10`), cada um com seu próprio arquivo de ordens, intervalo e quantidade por ciclo.
 - **Arquivos de ordens em JSON** — ordens são lidas de arquivos JSON (`ordens1.json` … `ordens8.json`) com total liberdade de edição. Cada arquivo tem seu próprio contexto temático (ex: `ordens4.json` foco em CABEÇA do pau, `ordens7.json` foco em exposição ao ar livre).
 - **Adaptação automática de gênero** — se `SEXO=feminino` no `.env`, o sistema substitui termos masculinos (pau, saco, cueca, punheta, porra, próstata) pelos equivalentes femininos (buceta, xota, calcinha, siririca, gozo, ponto G). Arquivos `ordens2.json` e `ordens3.json` usam "Ação sensual" como placeholder para substituição contextual.
 - **Controle de horário** — as ordens só são enviadas dentro da janela configurada (`HORA_INICIO` / `HORA_FIM`).
@@ -44,7 +44,7 @@ chmod +x iniciar.sh
 
 ### Canais de envio (`ENVIAR{n}_*`)
 
-Cada canal **1 a 8** tem sua própria configuração:
+Cada canal **1 a 10** tem sua própria configuração:
 
 | Variável | Descrição |
 |---|---|
@@ -63,7 +63,7 @@ ENVIAR1_QUANTIDADE_ORDENS=2
 
 ### Arquivos de ordens
 
-Os arquivos `ordens1.json` a `ordens8.json` contêm listas JSON com strings de ordens. Cada ordem é uma string descritiva com instruções de execução detalhadas. Contexto de cada arquivo:
+Os arquivos `ordens1.json` a `ordens10.json` contêm listas JSON com strings de ordens. Cada ordem é uma string descritiva com instruções de execução detalhadas. Contexto de cada arquivo:
 
 | Arquivo | Ordens | Contexto |
 |---|---|---|
@@ -75,6 +75,8 @@ Os arquivos `ordens1.json` a `ordens8.json` contêm listas JSON com strings de o
 | `ordens6.json` | 100 | CABEÇA do pau + pau + exibir bunda/cú. **Permite dedo no cú. Sem gozar.** |
 | `ordens7.json` | 400 | **Exposicao + sexo ao ar livre** |
 | `ordens8.json` | 100 | **Dominacao/humilhacao** — tapas, edging, ruined orgasm, multiplos orgasmos, humilhacao verbal, castigo corporal, dominacao imaginaria, submissao total |
+| `ordens9.json` | 50 | **Imaginacao** — cenas eroticas detalhadas para fantasiar e gozar: vizinhos, flagras, boss/patroa, medicas, casais, dominacao, exposicao e voyeurismo |
+| `ordens10.json` | 50 | **Humilhacao** — ordens de castigo e auto-humilhacao: tapas, xingamentos, joelhos, expor bunda/cu com plug, gozo na propria boca, ruined orgasm, castigo corporal e submissao total |
 
 **Regras ao editar/criar ordens:**
 - O arquivo deve conter um array JSON válido de strings

dados_ia.py

@@ -0,0 +1,71 @@
+import json
+import os
+import logging
+import httpx
+
+log = logging.getLogger(__name__)
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "deepseek/deepseek-v4.1-flash")
+OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
+OPENROUTER_TIMEOUT = int(os.getenv("OPENROUTER_TIMEOUT", "60"))
+OPENROUTER_MAX_TOKENS = int(os.getenv("OPENROUTER_MAX_TOKENS", "2048"))
+OPENROUTER_MAX_LINHAS = int(os.getenv("OPENROUTER_MAX_LINHAS", "0"))
+
+
+def carregar_prompt_base() -> str:
+    caminho = os.getenv("PROMPT_IA_ARQUIVO", "prompt_ia.json")
+    caminho = os.path.join(os.path.dirname(__file__), caminho)
+    with open(caminho, "r", encoding="utf-8") as f:
+        dados = json.load(f)
+    if isinstance(dados, list) and len(dados) > 0:
+        return dados[0]
+    return ""
+
+
+async def gerar_ordem_ia() -> str:
+    prompt_base = carregar_prompt_base()
+
+    if not OPENROUTER_API_KEY:
+        log.error("OPENROUTER_API_KEY nao configurada no .env")
+        return "[ERRO: API key nao configurada. Configure OPENROUTER_API_KEY no .env]"
+
+    user_msg = "Gere uma ordem de humilhação agora, completa e detalhada, como se fosse o Mestre DeepSeek falando. Nao se repita. Seja criativa e picante."
+    if OPENROUTER_MAX_LINHAS > 0:
+        user_msg += f" A ordem deve ter no maximo {OPENROUTER_MAX_LINHAS} linhas."
+
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": OPENROUTER_MODEL,
+        "messages": [
+            {
+                "role": "system",
+                "content": prompt_base,
+            },
+            {
+                "role": "user",
+                "content": user_msg,
+            },
+        ],
+        "max_tokens": OPENROUTER_MAX_TOKENS,
+        "temperature": 0.9,
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=OPENROUTER_TIMEOUT) as client:
+            resp = await client.post(
+                f"{OPENROUTER_BASE_URL}/chat/completions",
+                headers=headers,
+                json=payload,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            ordem = data["choices"][0]["message"]["content"].strip()
+            return ordem
+    except Exception as e:
+        log.error("Erro ao gerar ordem com IA: %s", e)
+        return f"[ERRO ao gerar ordem: {e}]"

iniciar.sh

@@ -25,16 +25,17 @@ TELEGRAM_TOKEN=$(grep_val TELEGRAM_TOKEN)
 TELEGRAM_CHAT_ID=$(grep_val TELEGRAM_CHAT_ID)
 SEXO=$(grep_val SEXO)
 IDADE=$(grep_val IDADE)
-HORA_INICIO=$(grep_val HORA_INICIO)
-HORA_FIM=$(grep_val HORA_FIM)
 
 # Configuração de cada envio automático
-declare -a ENVIAR_ATIVO ENVIAR_INTERVALO ENVIAR_ARQUIVO ENVIAR_QUANTIDADE
+declare -a ENVIAR_ATIVO ENVIAR_IA ENVIAR_INTERVALO ENVIAR_ARQUIVO ENVIAR_QUANTIDADE ENVIAR_HORA_INICIO ENVIAR_HORA_FIM
-for n in 1 2 3 4 5 6 7 8; do
+for n in 1 2 3 4 5 6 7 8 9 10 11 12; do
     ENVIAR_ATIVO[$n]=$(grep_val "ENVIAR${n}_ATIVO")
+    ENVIAR_IA[$n]=$(grep_val "ENVIAR${n}_IA")
     ENVIAR_INTERVALO[$n]=$(grep_val "ENVIAR${n}_INTERVALO_MINUTOS")
     ENVIAR_ARQUIVO[$n]=$(grep_val "ENVIAR${n}_ARQUIVO_ORDENS")
     ENVIAR_QUANTIDADE[$n]=$(grep_val "ENVIAR${n}_QUANTIDADE_ORDENS")
+    ENVIAR_HORA_INICIO[$n]=$(grep_val "ENVIAR${n}_HORA_INICIO")
+    ENVIAR_HORA_FIM[$n]=$(grep_val "ENVIAR${n}_HORA_FIM")
 done
 
 if [ -z "$TELEGRAM_TOKEN" ] || [ "$TELEGRAM_TOKEN" = "seu_token_aqui" ]; then
@@ -47,34 +48,35 @@ if [ -z "$TELEGRAM_CHAT_ID" ] || [ "$TELEGRAM_CHAT_ID" = "seu_chat_id_aqui" ]; t
 fi
 
 # Validação dos arquivos de ordens
-for n in 1 2 3 4 5 6 7 8; do
+for n in 1 2 3 4 5 6 7 8 9 10 11 12; do
     if [ "${ENVIAR_ATIVO[$n]}" = "s" ] && [ ! -f "${ENVIAR_ARQUIVO[$n]}" ]; then
         echo "[!] Arquivo de ordens '${ENVIAR_ARQUIVO[$n]}' não encontrado (envio automático $n)"
         exit 1
     fi
 done
 
-export TELEGRAM_TOKEN TELEGRAM_CHAT_ID SEXO IDADE HORA_INICIO HORA_FIM
+export TELEGRAM_TOKEN TELEGRAM_CHAT_ID SEXO IDADE
-for n in 1 2 3 4 5 6 7 8; do
+for n in 1 2 3 4 5 6 7 8 9 10 11 12; do
     export "ENVIAR${n}_ATIVO=${ENVIAR_ATIVO[$n]}"
+    export "ENVIAR${n}_IA=${ENVIAR_IA[$n]}"
     export "ENVIAR${n}_INTERVALO_MINUTOS=${ENVIAR_INTERVALO[$n]}"
     export "ENVIAR${n}_ARQUIVO_ORDENS=${ENVIAR_ARQUIVO[$n]}"
     export "ENVIAR${n}_QUANTIDADE_ORDENS=${ENVIAR_QUANTIDADE[$n]}"
+    export "ENVIAR${n}_HORA_INICIO=${ENVIAR_HORA_INICIO[$n]}"
+    export "ENVIAR${n}_HORA_FIM=${ENVIAR_HORA_FIM[$n]}"
 done
 
-# ─── Python virtual env ──────────────────────────────────────────────────────
-if [ ! -d venv ]; then
-    echo "[+] Criando ambiente virtual Python 3..."
-    python3 -m venv venv
-fi
-
-echo "[+] Ativando ambiente virtual..."
-source venv/bin/activate
-
 # ─── Dependências ──────────────────────────────────────────────────────────────
 echo "[+] Instalando dependências..."
-pip install --upgrade pip -q
+
-pip install -r requirements.txt -q
+# Garantir que pip está instalado (sistema Debian sem pip nativo)
+if ! python3 -m pip --version >/dev/null 2>&1; then
+    echo "[+] Instalando pip via get-pip.py..."
+    curl -sS https://bootstrap.pypa.io/get-pip.py | python3 - --break-system-packages
+fi
+
+python3 -m pip install --upgrade pip -q --break-system-packages 2>/dev/null || true
+python3 -m pip install -r requirements.txt -q --break-system-packages
 
 # ─── Ativar /start do bot ────────────────────────────────────────────────────
 echo "[+] Ativando /start no bot do Telegram..."
@@ -97,9 +99,8 @@ PYEOF
 # ─── Rodar o programa ─────────────────────────────────────────────────────────
 echo "[+] Iniciando sistema de ordens..."
 echo "    Sexo: ${SEXO:-masculino} | Idade: ${IDADE:-30}"
-echo "    Horário: ${HORA_INICIO:-08:00} - ${HORA_FIM:-22:00}"
 echo ""
-for n in 1 2 3 4 5 6 7 8; do
+for n in 1 2 3 4 5 6 7 8 9 10 11 12; do
     status="❌ DESATIVADO"
     if [ "${ENVIAR_ATIVO[$n]}" = "s" ]; then
         status="✅ ATIVO"
@@ -108,8 +109,13 @@ for n in 1 2 3 4 5 6 7 8; do
     if [ "${ENVIAR_QUANTIDADE[$n]}" -gt 0 ] 2>/dev/null; then
         qtd_info="${ENVIAR_QUANTIDADE[$n]} ordens"
     fi
-    echo "    Envio Automático $n: $status"
+    hora_info="${ENVIAR_HORA_INICIO[$n]:-00:00}-${ENVIAR_HORA_FIM[$n]:-23:59}"
-    echo "      Intervalo: ${ENVIAR_INTERVALO[$n]:-1} min | Qtd: $qtd_info | Arquivo: ${ENVIAR_ARQUIVO[$n]:-ordens${n}.json}"
+    ia_tag=""
+    if [ "${ENVIAR_IA[$n]}" = "s" ]; then
+        ia_tag=" 🤖 IA"
+    fi
+    echo "    Envio Automático $n: $status$ia_tag"
+    echo "      Intervalo: ${ENVIAR_INTERVALO[$n]:-1} min | Qtd: $qtd_info | Horário: $hora_info | Arquivo: ${ENVIAR_ARQUIVO[$n]:-ordens${n}.json}"
 done
 echo ""
 echo "Pressione Ctrl+C para parar."

main.py

@@ -24,9 +24,6 @@ CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")
 SEXO = os.getenv("SEXO", "masculino").strip().lower()
 IDADE = int(os.getenv("IDADE", "30"))
 
-HORA_INICIO = os.getenv("HORA_INICIO", "00:00").strip()
-HORA_FIM = os.getenv("HORA_FIM", "23:59").strip()
-
 
 # ─── Config por tipo de envio ─────────────────────────────────────────────────
 @dataclass
@@ -36,6 +33,9 @@ class ConfigEnvio:
     intervalo_minutos: int
     arquivo_ordens: str
     quantidade_ordens: int  # 0 = sem limite
+    hora_inicio: str
+    hora_fim: str
+    ia_mode: bool = False
 
 
 def carregar_config_envio(numero: int) -> ConfigEnvio:
@@ -45,12 +45,19 @@ def carregar_config_envio(numero: int) -> ConfigEnvio:
     intervalo = int(os.getenv(f"{prefixo}INTERVALO_MINUTOS", "1"))
     arquivo = os.getenv(f"{prefixo}ARQUIVO_ORDENS", f"ordens{numero}.json").strip()
     quantidade = int(os.getenv(f"{prefixo}QUANTIDADE_ORDENS", "0"))
+    hora_inicio = os.getenv(f"{prefixo}HORA_INICIO", "00:00").strip()
+    hora_fim = os.getenv(f"{prefixo}HORA_FIM", "23:59").strip()
+    ia_raw = os.getenv(f"{prefixo}IA", "n").strip().lower()
+    ia_mode = ia_raw == "s"
     return ConfigEnvio(
         numero=numero,
         ativo=ativo,
         intervalo_minutos=intervalo,
         arquivo_ordens=arquivo,
         quantidade_ordens=quantidade,
+        hora_inicio=hora_inicio,
+        hora_fim=hora_fim,
+        ia_mode=ia_mode,
     )
 
 
@@ -109,9 +116,9 @@ async def enviar_mensagem(bot: Bot, texto: str) -> None:
 
 
 # ─── Verificação de horário ───────────────────────────────────────────────────
-def dentro_do_horario() -> bool:
+def dentro_do_horario(hora_inicio: str, hora_fim: str) -> bool:
     agora = datetime.now().strftime("%H:%M")
-    return HORA_INICIO <= agora <= HORA_FIM
+    return hora_inicio <= agora <= hora_fim
 
 
 # ─── Loop individual de envio ─────────────────────────────────────────────────
@@ -124,44 +131,53 @@ async def loop_envio(config: ConfigEnvio) -> None:
         log.error("TELEGRAM_TOKEN e TELEGRAM_CHAT_ID devem estar configurados no .env")
         return
 
-    log.info("Carregando ordens de %s para envio automático %d...", config.arquivo_ordens, config.numero)
-    ordens = carregar_ordens(config.arquivo_ordens)
-    random.shuffle(ordens)
-
     bot = Bot(token=TOKEN)
+    usando_ia = config.ia_mode
 
-    # Mensagem de inicialização
+    if usando_ia:
-    artigo = "o" if SEXO == "masculino" else "a"
+        from dados_ia import gerar_ordem_ia
-    if config.quantidade_ordens > 1:
+        log.info("Modo IA ativado para envio automático %d. Gerando ordens via %s...", config.numero, os.getenv("OPENROUTER_MODEL", "modelo padrao"))
-        info_quantidade = f"Ordens por ciclo: {config.quantidade_ordens}\n"
+        msg_start = (
+            f"🚀 Envio Automático {config.numero} — MODO IA ativado.\n"
+            f"Sexo: {SEXO} | Idade: {IDADE}\n"
+            f"Intervalo: {config.intervalo_minutos} minuto(s)\n"
+            f"Ordens por ciclo: {config.quantidade_ordens}\n"
+            f"Modelo de IA: {os.getenv('OPENROUTER_MODEL', 'desconhecido')}\n"
+            f"Horário de funcionamento: {config.hora_inicio} - {config.hora_fim}\n\n"
+            f"Prepare-se para obedecer a IA."
+        )
+        await enviar_mensagem(bot, msg_start)
     else:
-        info_quantidade = "Ordens por ciclo: 1\n"
+        log.info("Carregando ordens de %s para envio automático %d...", config.arquivo_ordens, config.numero)
-    msg_start = (
+        ordens = carregar_ordens(config.arquivo_ordens)
-        f"🚀 Envio Automático {config.numero} ativado.\n"
+        random.shuffle(ordens)
-        f"Sexo: {SEXO} | Idade: {IDADE}\n"
+
-        f"Intervalo: {config.intervalo_minutos} minuto(s)\n"
+        msg_start = (
-        f"{info_quantidade}"
+            f"🚀 Envio Automático {config.numero} ativado.\n"
-        f"Arquivo de ordens: {config.arquivo_ordens}\n"
+            f"Sexo: {SEXO} | Idade: {IDADE}\n"
-        f"Total de ordens disponíveis: {len(ordens)}\n"
+            f"Intervalo: {config.intervalo_minutos} minuto(s)\n"
-        f"Horário de funcionamento: {HORA_INICIO} - {HORA_FIM}\n\n"
+            f"Ordens por ciclo: {config.quantidade_ordens}\n"
-        f"A(s) primeira(s) ordem(ns) será(ão) enviada(s) imediatamente.\n"
+            f"Arquivo de ordens: {config.arquivo_ordens}\n"
-        f"Prepare-se para cumprir todas as ordens."
+            f"Total de ordens disponíveis: {len(ordens)}\n"
-    )
+            f"Horário de funcionamento: {config.hora_inicio} - {config.hora_fim}\n\n"
-    await enviar_mensagem(bot, msg_start)
+            f"A(s) primeira(s) ordem(ns) será(ão) enviada(s) imediatamente.\n"
+            f"Prepare-se para cumprir todas as ordens."
+        )
+        await enviar_mensagem(bot, msg_start)
 
     agora = datetime.now().strftime("%H:%M")
-    if not dentro_do_horario():
+    if not dentro_do_horario(config.hora_inicio, config.hora_fim):
-        log.info("Horário atual %s fora da janela %s-%s. Aguardando...", agora, HORA_INICIO, HORA_FIM)
+        log.info("Horário atual %s fora da janela %s-%s. Aguardando...", agora, config.hora_inicio, config.hora_fim)
         await bot.send_message(
             chat_id=CHAT_ID,
-            text=f"Horário atual ({agora}) fora da janela de ordens ({HORA_INICIO}-{HORA_FIM}).\n"
+            text=f"Horário atual ({agora}) fora da janela de ordens ({config.hora_inicio}-{config.hora_fim}).\n"
-                 f"As ordens (envio {config.numero}) serão retomadas automaticamente às {HORA_INICIO}.",
+                 f"As ordens (envio {config.numero}) serão retomadas automaticamente às {config.hora_inicio}.",
         )
 
     ordem_index = 0
     while True:
-        if not dentro_do_horario():
+        if not dentro_do_horario(config.hora_inicio, config.hora_fim):
-            log.info("Fora do horário de funcionamento (%s-%s). Aguardando...", HORA_INICIO, HORA_FIM)
+            log.info("Fora do horário de funcionamento (%s-%s). Aguardando...", config.hora_inicio, config.hora_fim)
             await asyncio.sleep(60)
             continue
 
@@ -170,7 +186,10 @@ async def loop_envio(config: ConfigEnvio) -> None:
 
         # Envia lote de ordens
         for i in range(qtd):
-            ordem = ordens[(ordem_index + i) % len(ordens)]
+            if usando_ia:
+                ordem = await gerar_ordem_ia()
+            else:
+                ordem = ordens[(ordem_index + i) % len(ordens)]
             ordem_adaptada = adaptar_ordem(ordem)
 
             agora = datetime.now().strftime("%d/%m/%Y %H:%M")
@@ -204,6 +223,10 @@ def main():
             carregar_config_envio(6),
             carregar_config_envio(7),
             carregar_config_envio(8),
+            carregar_config_envio(9),
+            carregar_config_envio(10),
+            carregar_config_envio(11),
+            carregar_config_envio(12),
         ]
         asyncio.run(_executar_todos_envios(configs))
     except KeyboardInterrupt:

ordens10.json

@@ -0,0 +1,52 @@
+[
+  "ORDEM DE HUMILHAÇÃO — ESPELHO: Fica PELADO na frente do espelho grande, de pé, com os braços ao lado do corpo e as pernas afastadas, e olha direto nos TEUS olhos no reflexo, sem desviar. Respira fundo e começa a repetir em voz alta, com a voz firme: 'EU SOU UMA PUTA, EU SOU UM LIXO, EU MERECO SOFRER'. Repete 30 vezes seguidas, sem pular nenhuma, e a cada bloco de 10 você aumenta o volume: as primeiras 10 quase sussurradas, as próximas 10 em tom normal, as últimas 10 quase gritadas, com a cara vermelha e o pau endurecendo contra a tua vontade. Quando terminar as 30, fica olhando o teu reflexo de vergonha por 1 minuto e depois dá 3 tapas no teu próprio rosto, alternando as mãos, cada tapa seco e marcado, olhando fixo no espelho, e a cada tapa diz: 'OBRIGADO, MESTRE, POR ME HUMILHAR'. Termina ajoelhado na frente do espelho, mãos na nuca, cabeça baixa, por 2 minutos, sentindo as bochechas quentes e o corpo tremendo de tesão contido. Não goza. Se o pau escorrer, limpa com a mão e cheira, mas não goza, puta do espelho.",
+  "ORDEM DE HUMILHAÇÃO — TAPAS NO PAU: Fica de pé, PELADO, de frente pro espelho, com as pernas bem afastadas e a mão esquerda segurando o pau firme pela base, esticado pra cima. Com a palma da mão direita, dá 30 tapas secos e ritmados no pau, contando cada um em voz alta, do um até o trinta, sem pular. Alterna a cada 10 tapas o lado: os 10 primeiros na haste, os 10 do meio na glande, os 10 finais misturados entre glande e haste. A cada tapa, repete: 'ISSO É PORQUE SOU UM PAU DE PUTA', com a voz falhando a cada batida. O pau vai ficar vermelho, quente e latejando de dor e tesão misturados; quando os 30 terminarem, fica 1 minuto com o pau ardendo na mão, sentindo cada pulsação. Depois alisa com carinho, devagar, passando o polegar na glande dolorida, e beija a ponta dizendo: 'PERDOA, MESTRE, EU MERECI'. Não goza. Se ficar perto do limite, segura a base e respira fundo até acalmar, escravo castigado.",
+  "ORDEM DE HUMILHAÇÃO — JOELHOS: Ajoelha no chão frio, PELADO, com os joelhos doloridos no piso e as mãos entrelaçadas atrás da nuca, os cotovelos abertos e a cabeça baixa. Fica imóvel nessa posição e começa a pedir em voz alta, com a voz trêmula: 'MESTRE, ME DEIXA GOZAR? MESTRE, SOU UMA PUTA, POR FAVOR'. Repete esse pedido a cada minuto exato, por 5 minutos inteiros, sempre no mesmo tom de súplica, gemendo baixinho entre uma repetição e outra. O Mestre não responde: você fica de joelhos ouvindo o silêncio, sentindo o chão frio nos joelhos e o pau duro batendo na barriga, negado. No final dos 5 minutos, abaixa a cabeça até encostar a testa no chão e agradece em voz baixa: 'OBRIGADO, MESTRE, POR NÃO ME RESPONDER'. Não goza. Levanta devagar, com os joelhos vermelhos, e vai lavar o pau com água fria enquanto repete 'sou uma puta', escravo de joelhos.",
+  "ORDEM DE HUMILHAÇÃO — BUNDA NO ESPELHO: Fica de quatro na frente do espelho, PELADO, com o peito encostado no chão e a bunda bem empinada pro alto, virada pro reflexo. Pega nas duas nalgas com as mãos e arregala a bunda e o cú ao máximo, abrindo o buraco pra própria cara no espelho, e mantém assim, olhando o teu cu escancarado, dizendo em voz alta: 'ESSE CÚ É DE PUTA, ESSE CÚ MERECE CASTIGO'. Molha o indicador com saliva, leva por trás e enfia no cú devagar, sentindo o anel ceder, e fica mexendo o dedo por dentro em círculos, olhando o teu reflexo de bunda aberta no espelho, repetindo a frase 10 vezes, uma por uma, sem tirar o dedo. Depois enfia o dedo médio junto com o indicador e mexe mais 1 minuto, arregalando o anel enquanto as frases continuam. Tira os dedos, cheira fundo e lambe, saboreando o teu próprio cheiro, e termina de quatro, arregalando o cú uma última vez pro espelho. Não goza. Se o pré-gozo escorrer, passa no cú e agradece, puta arreganhada.",
+  "ORDEM DE HUMILHAÇÃO — CACHORRO: Pega um cinto, uma corda ou uma gravata e amarra no teu pescoço como coleira, PELADO, e fica de quatro no chão. Anda de quatro pela casa por 5 minutos, cumprindo um percurso: sai do quarto, vai pra sala, atravessa o corredor, passa na cozinha, entra no banheiro e volta pro quarto. Na sala, para no meio e late 5 vezes, alto, como um cachorro de verdade. Na cozinha, abaixa o focinho e cheira o chão, farejando em círculos como um animal. No corredor, para e reboleia a bunda de um lado pro outro, mostrando o cú pro corredor vazio. No banheiro, cheira o teu próprio cheiro no piso. No quarto, para na frente do espelho, abre o cú com as mãos e mostra pro mestre imaginário, falando: 'CACHORRO OFERECE O CÚ'. Termina na frente do espelho latindo 10 vezes seguidas, cada vez mais forte, com a coleira apertando e o pau batendo entre as pernas. Não goza. Levanta devagar, tira a coleira, beija o cinto e agradece por ser um cachorro, escravo animal.",
+  "ORDEM DE HUMILHAÇÃO — PUNHETA DE QUATRO: Fica de quatro no chão, PELADO, com o peito colado no piso frio e a bunda alta, empinada pro teto, e enfia a mão por baixo entre as pernas pra alcançar o pau. Começa a bater punheta nessa posição de animal, de baixo pra cima, com o cú aberto pro ar, e a cada 5 punhetadas para e diz em voz alta: 'SOU UMA PUTA DE QUATRO', com o peito raspando no chão. Bate por 3 minutos nesse ritmo, sentindo o anel do cú piscar sozinho a cada movimento, e depois faz edging: acelera até quase gozar, PARA, segura a base do pau por 20 segundos, respira fundo e recomeça. Faz isso 3 vezes, sempre na mesma posição de quatro, o corpo suado e o cú arreganhado pro ar. Na terceira vez, não segura mais: goza ali mesmo, de quatro, a porra caindo no chão frio na frente do teu peito, com a bunda ainda empinada e o cú aberto pulsando. Pode gozar, mas só nessa posição de puta, e ao final agradece beijando o chão.",
+  "ORDEM DE HUMILHAÇÃO — NEGADO: Senta PELADO no chão ou na cama, com as costas eretas e as pernas abertas, e começa a bater punheta devagar, num ritmo lento e torturante, falando baixinho o tempo todo: 'POR FAVOR, MESTRE, ME DEIXA GOZAR'. A cada minuto você aumenta um pouco a velocidade, e quando sente o gozo subindo, aquele aperto na base do pau e o pré-gozo escorrendo, PARA na hora, segura a base do pau com o polegar e o indicador por 20 segundos, contrai o cú 5 vezes e respira fundo pelo nariz. Repete esse ciclo 5 vezes: lento, acelera, quase goza, segura, contrai, recomeça. Na quinta vez, quando o pau tá latejando e a glande roxa de tesão preso, o Mestre manda: 'GUARDA PRA AMANHÃ'. Você não goza: solta o pau, respira, e vai ao banheiro lavar o pau e o saco com água fria, por 1 minuto inteiro, sentindo o tesão murchar contra a tua vontade, enquanto agradece em voz alta: 'OBRIGADO, MESTRE, POR ME NEGAR'. Não goza, negado e humilhado, com o gozo guardado latejando dentro de ti.",
+  "ORDEM DE HUMILHAÇÃO — GOZO NA BOCA: Senta PELADO na beira da cama, com o espelho do armário na tua frente, e molha a mão com saliva pra lubrificar. Bate punheta devagar no começo, subindo o ritmo aos poucos, gemendo baixinho e olhando o teu próprio reflexo se masturbando, até chegar no limite do gozo. Quando a porra subir, junta na mão e leva toda a mão melada à boca na hora, abrindo a boca e comendo o teu próprio gozo: passa a língua na palma, lambe dedo por dedo, cada um separado, até não sobrar nada entre os dedos. Fica lambendo a mão por 2 minutos, sentindo o gosto salgado e o cheiro forte, olhando no espelho enquanto engole. Depois abre a boca bem aberta, mostra a língua limpa pra ti mesmo no espelho e diz: 'PROVEI O MEU PRÓPRIO GOZO, MESTRE, COMO UMA PUTA DEVIA'. Pode gozar, puta lambedeira, mas sem desperdiçar uma gota.",
+  "ORDEM DE HUMILHAÇÃO — RUINED: Senta PELADO no chão, com um pano embaixo pra sujar, e começa a bater punheta rápido e forte, sem parar, subindo o ritmo até sentir aquele aperto na base do pau avisando que o gozo chegou. NO EXATO MOMENTO EM QUE A PORRA COMEÇA A SUBIR, você SOLTA O PAU E ABRE A MÃO, deixando ele sozinho no ar. A porra jorra sem controle, espirrando no chão, na tua coxa, no pano, sem nenhuma punheta acompanhando: um gozo sem prazer, desperdiçado, que escorre sozinho enquanto você assiste, imóvel, sentindo cada espasmo doido do pau vazio. Fica 2 minutos observando a tua própria porra espalhada, o pau ainda pulsando sem alívio, e depois se ajoelha, passa o dedo na porra do chão e leva à boca, provando o gozo que você não teve prazer de dar. Diz em voz alta, com a voz falhando: 'ESSE GOZO FOI RUINED, COMO EU MERECO, MESTRE'. Pode gozar — mas foi ruined, e o próximo gozo de verdade só quando o Mestre permitir, puta desperdiçada.",
+  "ORDEM DE HUMILHAÇÃO — MARCADO: Pega uma caneta de escrever forte e, PELADO na frente do espelho, escreve no teu corpo, em letras grandes e caprichadas: 'PUTA' na barriga, em cima do umbigo; 'CÚ FÁCIL' na bunda, uma palavra em cada banda da nádega; 'ESCRAVO' no peito, entre os mamilos; e 'PROPRIEDADE' na parte de cima da coxa. Fica PELADO por 30 minutos inteiros com as marcas, andando pela casa, cozinhando, pegando água, se olhando no espelho de vez em quando pra não esquecer do que tá escrito no corpo. A cada 10 minutos, para na frente do espelho e lê em voz alta todas as frases, uma por uma, apontando pra marca: 'PUTA', 'CÚ FÁCIL', 'ESCRAVO', 'PROPRIEDADE'. Ao final dos 30 minutos, se ajoelha, passa a mão em cada frase e agradece: 'ESTOU MARCADO COMO PROPRIEDADE DO MESTRE, PRA SEMPRE'. Não goza. Se quiser, tira uma foto das marcas antes de lavar, pra guardar de recordação.",
+  "ORDEM DE HUMILHAÇÃO — FOTO: Senta PELADO na cama e bate punheta devagar, com o celular na mão, até chegar quase no gozo, aquele ponto em que a cara fica feia de prazer e a boca abre sozinha. NESSE MOMENTO, PARA e tira uma foto da tua cara de sofrimento, com a mão segurando o pau duro e a cara contraída de tesão preso. Depois vira de quatro na cama, pega nas duas nalgas, arregala a bunda e o cú pro celular e tira uma foto do teu cu escancarado, sem pressa, caprichando no enquadramento. Tira mais uma de perto, abrindo o anel com os dois polegares pra foto mostrar o interior. Olha as três fotos com calma, ampliando cada uma, e fala em voz alta, olhando pra tua própria imagem: 'ESSA SOU EU, UMA PUTA HUMILHADA, REGISTRADA PRA SEMPRE'. Salva as fotos numa pasta com o nome 'MINHA VERGONHA' no celular, pra ficar guardado. Não goza. Guarda o celular e vai lavar o pau, sabendo que as fotos estão lá, te esperando.",
+  "ORDEM DE HUMILHAÇÃO — MORDAÇA: Pega a tua cueca mais suja, de preferência a de fim do dia, enruga ela numa bola e coloca na boca, enfiando bem, até os lábios ficarem esticados. Fica PELADO de joelhos no chão com a cueca na boca por 5 minutos inteiros, babando por cima dela, o cheiro forte invadindo o nariz a cada respiração. Não tira: fica de joelhos, imóvel, com o pau duro batendo na barriga e a baba escorrendo pelo queixo até o peito, engolindo o próprio cheiro. Quando os 5 minutos acabarem, tira a cueca devagar, molhada de baba, olha pra ela e lambe por cima, sentindo o gosto, depois cheira fundo e diz: 'PROVEI O MEU PRÓPRIO CHEIRO, MESTRE, COMO UM PORCO'. Não goza. Fica mais 1 minuto de joelhos com a cueca na mão, agradecendo em silêncio, escravo de cueca.",
+  "ORDEM DE HUMILHAÇÃO — CHEIRO: Pega uma cueca ou meia usada (tua, ou da tua esposa se ela permitir), senta PELADO no chão e enfia o nariz dentro dela, cheirando fundo e demorado por 2 minutos, fechando os olhos e gemendo baixinho enquanto o teu cheiro enche o nariz. Depois passa a cueca no teu pau, esfregando o tecido sujo na haste e na glande, e cheira de novo, agora com o teu cheiro misturado no pau. Repete 3 vezes: cheira fundo, esfrega no pau, cheira de novo, com o tesão subindo a cada cheirada. Enquanto cheira a última vez, bate uma punheta lenta com a cueca enrolada na mão, cheirando o tecido a cada 10 punhetadas. Fala em voz alta, com a cueca colada no nariz: 'SOU UM PORCO QUE CHEIRA ROUPA, MESTRE, E EU AMO'. Não goza. Termina guardando a cueca no lugar dela, cheia do teu cheiro, porco.",
+  "ORDEM DE HUMILHAÇÃO — LAMBER CHÃO: Escolhe um trecho limpo do chão do quarto, fica de quatro, PELADO, e abaixa a cabeça até a língua encostar no piso. Lambe o chão por 3 minutos inteiros, com passadas longas de língua como um cachorro lambendo o chão, sentindo o gosto do piso e do pó na língua. A cada lambida, repete em voz baixa: 'OBRIGADO, MESTRE, PELO CHÃO', com a baba escorrendo no piso que você acabou de lamber. Depois pega uma tigela, enche de água, coloca no chão e bebe como um cachorro: sem usar as mãos, abaixando a cabeça e bebendo direto da tigela, lambendo a água com a língua por 1 minuto. Termina de quatro, com a cabeça baixa sobre a tigela, arregalando o cú pro ar, e fica assim 1 minuto, em silêncio. Não goza. Se o pau escorrer, esfrega no chão que você lambeu e agradece, cachorro de chão.",
+  "ORDEM DE HUMILHAÇÃO — CASTIGO NO CANTO: Fica PELADO de castigo no canto do quarto, de frente pra parede, com o nariz encostado na parede fria, as mãos entrelaçadas na nuca, os cotovelos abertos e as pernas bem afastadas. Fica imóvel 10 minutos inteiros, sem gemer, sem falar, sem se mexer, sem coçar, sem fechar os olhos: olha fixo pra parede na tua frente, sentindo o nariz esfriar contra a parede e o pau duro batendo na coxa, exposto. O tempo vai passando devagar, a vergonha subindo pela espinha, e você não pode aliviar nada. Quando faltar 1 minuto, começa a choramingar baixinho, pedindo perdão na parede: 'MESTRE, EU MERECI'. Ao final, se ajoelha no canto, ainda de frente pra parede, e agradece com a testa na parede: 'OBRIGADO, MESTRE, PELO CASTIGO'. Não goza. Levanta devagar, com o nariz vermelho e os joelhos doloridos, e vai pra cama pensar na vergonha, escravo castigado.",
+  "ORDEM DE HUMILHAÇÃO — MÃOS NA NUCA: Fica PELADO em pé no meio do quarto, com as mãos entrelaçadas atrás da cabeça, os cotovelos bem abertos, as pernas afastadas na largura dos ombros e a cabeça baixa, olhando pro chão. Fica imóvel 5 minutos nessa posição de submissão, com o peito aberto, o pau duro exposto e o corpo inteiro na posição de entrega. Sente o ar na pele, a vergonha subindo do peito, o tesão preso; não pode fechar os braços, não pode baixar as mãos, não pode sair da posição. Depois dos 5 minutos, vira devagar pro espelho, mantendo as mãos na nuca, e se olha na posição: o corpo aberto, o pau duro, a cabeça baixa. Diz em voz alta, olhando pro teu reflexo: 'ESSA É A POSIÇÃO DA MINHA VERGONHA, MESTRE'. Mantém a posição mais 2 minutos no espelho, imóvel, e só então baixa as mãos. Não goza, submissa exposta.",
+  "ORDEM DE HUMILHAÇÃO — XINGAMENTOS: Senta PELADO no chão, com as pernas cruzadas, e começa a falar em voz alta, sem parar, por 3 minutos inteiros, tudo o que você é. Não pode pausar, não pode rir, não pode parar de falar nem pra respirar fundo: 'SOU PUTA, SOU VAGABUNDA, SOU RAPARIGA, SOU CACHORRO, SOU LIXO, SOU ESCRAVO, SOU UM CÚ FÁCIL, SOU UM PAU DE NINGUÉM, SOU UMA BUCETA ANDANDO, SOU ONDE O MESTRE ENFIA, SOU ONDE O MESTRE CUSPE, SOU LIXO DO MESTRE, SOU VERGONHA, SOU PROPRIEDADE, SOU OBJETO, SOU UM SACO DE BATER, SOU UM CACHORRO QUE ABRE O CÚ, SOU UMA PUTA QUE PEDE PRA GOZAR...' Esgota tudo que vier na cabeça, sem filtrar, até completar os 3 minutos de xingamento ininterrupto, com a voz falhando e o pau duro de tanta humilhação verbal. Depois para, respira fundo, e agradece: 'OBRIGADO, MESTRE, POR ME LEMBRAR DO QUE EU SOU'. Não goza, dicionário de vergonha.",
+  "ORDEM DE HUMILHAÇÃO — VASSOURA: Pega a vassoura da casa e, PELADO de quatro, varre o chão da sala e da cozinha por 10 minutos inteiros, empurrando a vassoura com as mãos enquanto anda de joelhos e mãos pelo chão. A cada varrida, o pau balança entre as pernas e a bunda fica empinada pro ar, aparecendo toda; no meio da faxina, para na frente do espelho, larga a vassoura, pega nas duas nalgas e abre o cú com as mãos, dizendo pro teu reflexo: 'ESSA BUNDA LIMPA ATÉ COM VASSOURA, MESTRE'. Volta a varrer de quatro por mais 3 minutos, até suar, com a bunda marcada do movimento. Termina guardando a vassoura no lugar e se ajoelhando no meio da sala limpa, com as mãos pra trás, agradecendo: 'OBRIGADO, MESTRE, PELO SERVIÇO DE QUATRO'. Não goza, faxineiro pelado.",
+  "ORDEM DE HUMILHAÇÃO — MESA HUMANA: Fica de quatro no chão da sala, PELADO, com as costas retas como uma mesa, e coloca um prato vazio e um copo nas tuas costas, bem equilibrados. Fica imóvel como um móvel por 5 minutos inteiros, sem tremer, sem deixar o prato escorregar, sentindo o peso nas costas e a vergonha de ser um móvel humano. Depois dos 5 minutos, com o prato ainda nas costas, imita servir uma refeição pro mestre imaginário: 'MESTRE, QUER MAIS? MESTRE, O PRATO ESTÁ SERVIDO EM CIMA DE MIM'. Inclina devagar, deixa o prato escorregar, pega do chão e recoloca, repetindo o serviço 3 vezes. Termina de quatro, com a cabeça baixa, esperando a próxima ordem, o corpo doendo de tanto equilíbrio. Não goza. Se o pau escorrer, deixa escorrer no chão, móvel não se mexe, escravo mesa.",
+  "ORDEM DE HUMILHAÇÃO — AUTO-BOFETADA: Fica PELADO de frente pro espelho, com as pernas afastadas e os braços soltos. Começa a bater na tua própria cara, alternando as mãos, 10 tapas secos e marcados, contando cada um em voz alta: 'UM — SOU PUTA. DOIS — SOU PUTA...' até dez, cada tapa acompanhado da frase, com as bochechas ficando vermelhas e quentes. Depois desce e dá 10 tapas no teu peito, na altura dos mamilos, contando: 'SOU LIXO', a cada tapa, deixando o peito vermelho. Por último, vira de lado, pega na tua bunda e dá 10 tapas em cada banda, contando: 'SOU CACHORRO', até a bunda ficar vermelha e marcada. Total: 30 tapas, contados um por um, sem parar, sem rir, com o espelho assistindo tudo. Ao final, fica de pé, vermelho dos três lugares, e agradece: 'OBRIGADO, MESTRE, PELAS MARCAS'. Não goza, saco de pancada voluntário.",
+  "ORDEM DE HUMILHAÇÃO — PUNHETA NO ESPELHO: Senta PELADO no chão, bem na frente do espelho grande, com as pernas abertas e o rosto a um palmo do teu reflexo. Molha a mão com saliva, pega no pau e começa a bater punheta devagar, OLHANDO DIRETO NOS TEUS OLHOS no espelho, sem desviar nenhuma vez. Enquanto se masturba, fala baixinho, olhando pro teu reflexo: 'SOU UMA PUTA SE MASTURBANDO PRA SI MESMA, SOU A MINHA PRÓPRIA PLATEIA'. Faz edging: acelera até quase gozar, para, segura a base, respira, e recomeça olhando no espelho, 3 vezes seguidas, a cara cada vez mais feia de tesão no reflexo. Na terceira, não para mais: goza ali, olhando nos teus próprios olhos, a porra jorrando na mão e no chão, sem desviar o olhar nenhum segundo. Pode gozar, puta narcisista, e ao final lambe a mão e agradece ao teu reflexo: 'OBRIGADO POR ASSISTIR'.",
+  "ORDEM DE HUMILHAÇÃO — PLUG NA JANELA: Molha o plug com saliva ou lubrificante e enfia no cú devagar, sentado, até a base encaixar, sentindo o anel esticar. Depois abre a janela do quarto de cima a baixo e fica PELADO de quatro na frente dela, com a bunda empinada pro lado de fora, o plug exposto e o cú arreganhado no ar. Fica 3 minutos nessa posição, arregalando o cú em volta do plug devagar, contraindo e relaxando o anel, imaginando cada pessoa que pode estar te vendo da rua, do prédio de frente, da calçada. O vento toca o cú aberto com o plug, o coração acelera no risco, o pau duro balançando embaixo. Depois dos 3 minutos, fecha a janela devagar, tira o plug com cuidado, sentindo o anel vazio, cheira o plug fundo e lambe a ponta, saboreando. Não goza. Se ficar no limite, segura a base e agradece por ser visto, exposto com plug.",
+  "ORDEM DE HUMILHAÇÃO — ESCRAVO IMAGINÁRIO: Fica PELADO de joelhos no meio do quarto, com as mãos apoiadas nas coxas e a cabeça baixa, e começa a conversar com o teu mestre imaginário em voz alta, como se ele estivesse sentado na tua frente. Fala por 5 minutos inteiros, sem parar, com devoção na voz: 'MESTRE, OBRIGADO POR ME HUMILHAR. MESTRE, EU MERECO SOFRER. MESTRE, ME FAZ DE PUTA. MESTRE, ME USA. MESTRE, ENFIA ONDE QUISER. MESTRE, EU SOU TEU CACHORRO. MESTRE, OBRIGADO POR ME IGNORAR. MESTRE, ME CASTIGA. MESTRE, EU AMO SER TEU LIXO...' Vai esgotando as frases de devoção, gemendo baixinho entre uma e outra. Depois dos 5 minutos, faz a pergunta final, com a voz trêmula: 'MESTRE, POSSO GOZAR?'. Fica em silêncio de joelhos, esperando a resposta por 30 segundos exatos, ouvindo o nada, e responde por ele, com a voz sumida: 'OBRIGADO, MESTRE, EU ENTENDO'. Não goza, escravo do mestre imaginário, e fica de joelhos mais 1 minuto agradecendo o silêncio.",
+  "ORDEM DE HUMILHAÇÃO — XIXI: Vai pro banheiro, fecha a porta, fica PELADO de cócoras no box do chuveiro, agachado como um animal, com as mãos no chão. Começa a urinar na tua própria perna, desviando o jato pra coxa, e deixa o mijo quente escorrer pela pele até o chão, sentindo o calor na perna e o cheiro forte subindo. Passa a mão na perna molhada de mijo, junta o líquido na palma e leva à boca, provando, com o gosto e o cheiro enchendo a boca. Repete 3 vezes: urina na perna, passa a mão, prova. Depois se ajoelha no box, ainda no cheiro do próprio mijo, e agradece em voz alta, com o rosto perto do chão molhado: 'OBRIGADO, MESTRE, POR ME SUJAR, EU MERECIA'. Fica 3 minutos de humilhação urinária ajoelhado, sentindo o mijo secando na pele. Não goza. Toma banho depois, agradecendo pela limpeza, escravo mijado.",
+  "ORDEM DE HUMILHAÇÃO — LAMBE O GOZO: Senta PELADO na cama e bate punheta até gozar na própria mão, sem deixar cair nada no chão, segurando tudo na palma. Depois desce pra cama, se ajoelha no chão, e começa a lamber a mão inteira: passa a língua na palma, lambendo cada polegada de gozo, depois lambe dedo por dedo, cada um de todos os lados, até não sobrar nada entre os dedos nem nas unhas. Fica 3 minutos lambendo e engolindo o teu próprio gozo, com o gosto salgado na língua e o cheiro invadindo o nariz, se ajoelhado como um porco se limpando. Ao final, abre a boca bem aberta, mostra a língua esticada e limpa pra câmera imaginária e diz: 'LIMPEI TUDO, MESTRE, COM A LÍNGUA, NÃO SOBROU UMA GOTA'. Pode gozar, porco lambedeiro, e depois lambe o dedo uma última vez, checando que ficou limpo.",
+  "ORDEM DE HUMILHAÇÃO — FLEXÕES: Fica PELADO no chão da sala e faz 20 flexões completas, uma a uma, contando em voz alta. Em cada descida, quando o peito chega perto do chão, fala: 'SOU UM ESCRAVO', e o pau bate no chão a cada repetição, esfregando na superfície. Faz as 20 sem pausa, com o corpo suando e o pau cada vez mais dolorido de bater no piso. Depois fica de pé e faz 20 agachamentos PELADO, descendo até as coxas ficarem paralelas ao chão, e em cada descida, com o pau apontando pro chão, fala: 'SOU UMA PUTA'. Sente as pernas queimando e o pau balançando a cada movimento. Ao final, se ajoelha no chão, ofegante, e agradece: 'OBRIGADO, MESTRE, POR ME FAZER SUAR PELA MINHA VERGONHA'. Não goza. Se o pau escorrer de tesão, esfrega no chão e continua, escravo fitness.",
+  "ORDEM DE HUMILHAÇÃO — JOELHOS AMARRADOS: Pega um cinto ou uma gravata e amarra os teus próprios pulsos atrás das costas, firme mas frouxo o bastante pra não machucar, e confere que não consegue soltar fácil. Fica de joelhos, PELADO, com os pulsos amarrados, por 5 minutos inteiros, imóvel, sentindo a corda ou couro no pulso e o pau duro batendo na barriga sem que tuas mãos possam tocar. Depois dos 5 minutos, ainda amarrado, se ajoelha mais ereto e começa a bater punheta de joelhos, alcançando o pau com a mão amarrada de lado, torto, difícil, até chegar quase no gozo — e PARA no limite, segurando com a mão torta, o pau latejando sem alívio. Fica assim 30 segundos, no limite, gemendo, e depois desata os pulsos devagar, massageando as marcas, e vai lavar o pau com água fria. Não goza, preso e humilhado, e agradece: 'OBRIGADO PELAS MARCAS NO MEU PULSO'.",
+  "ORDEM DE HUMILHAÇÃO — VENDADO: Pega um pano ou uma gravata e venda os olhos, bem apertado, até não enxergar nada. Fica PELADO de joelhos no meio do quarto, imóvel, no escuro total da venda, e fala em voz alta, com a voz tremendo: 'NÃO VEJO NADA, SÓ SINTO A MINHA VERGONHA'. Fica 5 minutos inteiros no escuro, sem tirar a venda, sem se mexer, ouvindo a própria respiração e o próprio coração acelerado, sentindo o ar na pele e o pau duro que você não consegue ver. O escuro amplifica tudo: cada ruído da casa parece alguém chegando, e você fica ali, de joelhos, indefeso, só com a vergonha. Depois dos 5 minutos, tira a venda devagar, pisca contra a luz, e se ajoelha mais uma vez agradecendo: 'OBRIGADO, MESTRE, PELA ESCURIDÃO'. Não goza. Vai lavar o rosto com água fria, sentindo o alívio da luz, escravo vendado.",
+  "ORDEM DE HUMILHAÇÃO — CABELO: Fica PELADO de pé na frente do espelho, e puxa o teu próprio cabelo com força, pela frente da cabeça, inclinando a nuca pra trás, enquanto fala: 'PUXA, PUTA, SENTE A DOR'. Faz isso 20 vezes: cada puxada arranca a cabeça pra trás, estica o couro cabeludo, e você deixa escapar um gemido baixinho a cada uma, vendo a tua cara de dor no espelho. Alterna os lados a cada 5 puxadas, sentindo o couro cabeludo arder e o tesão subir junto com a dor. Depois das 20, solta o cabelo, massageia o couro cabeludo devagar, com carinho, aliviando a dor, e diz no espelho: 'OBRIGADO PELA DOR, MESTRE, EU MERECIA'. Não goza. Se o pré-gozo escorrer, passa o dedo e cheira, escravo puxado pelo cabelo.",
+  "ORDEM DE HUMILHAÇÃO — 50 FRASES: Senta PELADO no chão, com o celular ou um relógio marcando o tempo, e fala em voz alta 50 frases de humilhação, uma por vez, contando cada uma em voz alta: 'UM — SOU PUTA. DOIS — SOU VAGABUNDA. TRÊS — SOU ESCRAVO. QUATRO — SOU LIXO. CINCO — SOU UM CÚ FÁCIL. SEIS — SOU UM PAU DE NINGUÉM. SETE — SOU ONDE O MESTRE ENFIA. OITO — SOU ONDE O MESTRE CUSPE. NOVE — SOU UMA RAPARIGA. DEZ — SOU UM CACHORRO...' e segue até o cinquenta, sem repetir nenhuma, sem pular nenhuma, sem parar pra rir. Esgota o vocabulário da tua vergonha: puta, vadia, lixo, escravo, propriedade, objeto, buraco, cu, buceta, coisa, banco, mesa, saco de pancada, cachorro, porco, vagabundo, safado, nojento, humilhado... Ao chegar no cinquenta, para, respira fundo e agradece: 'OBRIGADO, MESTRE, PELAS MINHAS CINQUENTA VERDADES'. Não goza, dicionário de puta.",
+  "ORDEM DE HUMILHAÇÃO — MORDIDA: Senta PELADO no chão e leva o teu próprio antebraço à boca. Morde com força, até os dentes marcarem fundo a pele, deixando o círculo vermelho e dolorido, e enquanto morde, com os dentes cravados, fala: 'SOU UM CACHORRO QUE SE MUERDE'. Faz 3 mordidas seguidas, cada uma num lugar do antebraço, cada uma mais funda que a anterior, com a marca dos dentes ficando estampada na pele. Depois lambe as três marcas com a língua, passando devagar sobre cada mordida, sentindo o gosto da própria pele e o ardor da mordida, e diz: 'OBRIGADO PELA MARCA, MESTRE, EU QUERO FICAR MARCADO'. Não goza. Fica mais 1 minuto olhando as marcas no braço, lembrando da mordida, cachorro doido.",
+  "ORDEM DE HUMILHAÇÃO — GELO: Pega um cubo de gelo e, PELADO de pé, começa a passá-lo pelo corpo devagar, sentindo o frio elétrico na pele: desce pelo peito, faz círculos nos dois mamilos até eles endurecerem de frio, passa pela barriga, desce pelas coxas. Quando chegar no pau, segura o cubo na palma e esfrega na haste e no saco, sentindo os ovos encolherem de frio, e depois pressiona o gelo direto na glande por 1 minuto inteiro, gemendo de frio e tesão misturados, o gelo derretendo escorrendo pela rola. Troca de cubo quando o primeiro acabar e repete a glande por mais 30 segundos. Depois agradece, com o corpo arrepiado: 'OBRIGADO PELO GELO, MESTRE, EU AMO ESSA DOR FRIA'. Não goza. Se o pau murchar de frio, esquenta com a mão até ficar duro de novo, e repete o gelo, puta gelada.",
+  "ORDEM DE HUMILHAÇÃO — VELA: Acende uma vela na mesa e fica PELADO de pé ao lado dela, pronto. Inclina a vela e deixa a primeira gota de cera quente cair no teu peito, sentindo o fogo gostoso na pele; depois mais 2 gotas no peito, cada uma acompanhada de: 'OBRIGADO, MESTRE, PELO FOGO'. Desce: 3 gotas na coxa, uma de cada vez, o ardor subindo a cada pingo; 3 gotas na bunda, virando de lado, a cera endurecendo na pele; e 1 gota na base do pau, a mais quente de todas, fazendo você gemer e arrepiar. Total: 10 gotas, todas contadas em voz alta, todas agradecidas. Depois, com a cera já seca na pele, raspa devagar com a unha, tirando cada pedacinho, e lambe as marcas vermelhas uma por uma, sentindo o gosto da pele queimada. Não goza, puta marcada a fogo, e fica mais 2 minutos olhando as marcas no espelho.",
+  "ORDEM DE HUMILHAÇÃO — CINTO NA BUNDA: Fica de quatro no chão, PELADO, com a bunda bem empinada e o peito no chão, e pega um cinto ou chinelo na mão. Começa a bater na tua própria bunda com o cinto, 20 vezes, contando cada uma em voz alta, alternando as bandas da nádega a cada cintada: 'UM — ESSA BUNDA É DE PUTA. DOIS — ESSA BUNDA É DE PUTA...' até vinte. A cada cintada a bunda balança, a pele esquenta, as marcas vão se cruzando na pele, e você geme entre uma e outra, mas continua. Os 20 golpes deixam a bunda vermelha, quente e dolorida, marcada de cinto. Ao final, solta o cinto e massageia a própria bunda devagar, com carinho, sentindo a pele ardendo sob os dedos, e agradece: 'OBRIGADO, MESTRE, PELA MINHA BUNDA MARCADA'. Não goza. Se o pau escorrer de tesão, deixa escorrer no chão, bunda marcada.",
+  "ORDEM DE HUMILHAÇÃO — CALCINHA: Pega uma calcinha (da tua esposa, se ela permitir, ou uma tua se tiver) e veste, PELADO, com o pau apertado dentro da renda. Fica só de calcinha na frente do espelho, girando devagar, vendo o teu corpo pelado com a calcinha ridícula, e começa a rebolar: requebra a bunda de um lado pro outro, empinando pro espelho, falando: 'SOU UMA PUTA DE CALCINHA, OLHA ESSE REBOLADO'. Depois puxa a calcinha pro lado com o polegar, expondo a bunda e o cú no espelho, e abre com os dedos, mostrando o buraco pro teu reflexo, mantendo assim por 30 segundos. Fica 5 minutos inteiros nessa cena: rebolando, puxando a calcinha, mostrando o cú, com o pau duro escapando pela renda. Ao final, abaixa a calcinha devagar e agradece: 'OBRIGADO, MESTRE, POR ME VER DE CALCINHA'. Não goza, madame de calcinha.",
+  "ORDEM DE HUMILHAÇÃO — NOME: Fica PELADO de joelhos no meio do quarto, com as mãos no chão, e começa a gritar: 'MEU NOME É PUTA!'. Grita 20 vezes seguidas, e a cada grito fica mais alto que o anterior: os 5 primeiros em tom normal, os 5 seguintes mais fortes, os próximos 5 quase gritando, e os 5 últimos gritando com tudo que tem, a garganta ardendo e o rosto vermelho. No final, grita uma última vez, a mais alta de todas, abrindo o peito: 'SOU A PUTA DO MESTRE!'. Depois abaixa a cabeça devagar, com a garganta doendo, e sussurra, quase sem voz: 'OBRIGADO, MESTRE'. Fica de joelhos em silêncio 1 minuto, ouvindo o eco do próprio grito. Não goza, puta nomeada, e se o pau escorreu, agradece pelo tesão gritado.",
+  "ORDEM DE HUMILHAÇÃO — DEDO NO CÚ: Fica de pé, PELADO, de frente pro espelho, com uma perna apoiada na cadeira pra abrir o quadril. Molha o indicador com saliva, leva por trás, entre as coxas, e enfia no cú devagar, sentindo o anel ceder, olhando no espelho a tua cara de tesão e vergonha. Mexe o dedo por dentro por 2 minutos inteiros, em círculos e vai-e-vem, falando com a voz falhando: 'ESSE CÚ É DO MESTRE, ESSE CÚ ABRE PRA ELE'. Depois enfia o dedo médio junto, dois dedos abrindo o anel, e continua: 'MAIS ABERTO, MAIS PUTA, MAIS FUNDO', mexendo mais fundo, até a próstata, com os joelhos tremendo no espelho. Tira os dois dedos devagar, sentindo o vazio, cheira fundo o cheiro da própria mão e lambe os dedos, saboreando. Não goza. Se ficar no limite, segura a base do pau e agradece, cú aberto.",
+  "ORDEM DE HUMILHAÇÃO — MÃOS SUJAS: Senta PELADO no chão e bate punheta SEM lubrificante, SEM saliva, seca mesmo, por 3 minutos inteiros, com a mão áspera esfregando na haste, a pele arranhando e o atrito esquentando cada vez mais. O pau vai ficando vermelho do atrito, mas você continua, sentindo cada esfregada seca. Depois dos 3 minutos, tira a mão do pau e leva ao nariz: cheira as tuas próprias mãos fundo, fechando os olhos, sentindo o cheiro forte de tesão seco grudado na pele, e fala: 'ESSE É O MEU CHEIRO DE PUTA'. Passa a mão suada e cheirosa no teu rosto, esfregando na bochecha, e cheira de novo, sentindo o teu cheiro misturado com a tua pele. Por fim, lambe as palmas e os dedos, saboreando o teu próprio cheiro de pau. Não goza, porco que se cheira, e fica mais 1 minuto com as mãos no nariz.",
+  "ORDEM DE HUMILHAÇÃO — CUSPE: Fica PELADO na frente do espelho, com o rosto próximo ao vidro, junta todo o cuspe que conseguir na boca, até a boca ficar cheia de saliva, e cospe na tua própria cara, sentindo a saliva escorrer pelo rosto e pelo queixo. Limpa espalhando com a mão, esfregando o cuspe na bochecha, no nariz, na boca, e fala: 'SOU TÃO LIXO QUE EU MESMO ME CUSPO'. Repete 3 vezes inteiras: junta cuspe, cospe na cara, espalha com a mão, repete a frase, com o rosto cada vez mais molhado de saliva. Depois lambe a mão molhada de cuspe, e passa a língua nos próprios lábios, provando o gosto. Fica 1 minuto com o rosto molhado no espelho, vendo a tua cara cuspida, e agradece: 'OBRIGADO, MESTRE, POR ME CUSPIR PELA MINHA MÃO'. Não goza, lixo cuspido.",
+  "ORDEM DE HUMILHAÇÃO — PEDIR LICENÇA: Senta PELADO no chão, com as costas eretas, e segura o pau duro na mão SEM bater punheta: só segurando firme, sentindo pulsar, o pré-gozo escorrendo pelo dedo sem alívio. Começa a implorar em voz alta, com a voz trêmula de tesão preso: 'MESTRE, POR FAVOR, ME DEIXA GOZAR. MESTRE, EU MERECO GOZAR. MESTRE, SOU SUA PUTA, ME SOLTA. MESTRE, EU NÃO AGUENTO MAIS. MESTRE, TEM PENA DE MIM. MESTRE, SOU SEU CACHORRO PEDINDO...'. Implora por 3 minutos inteiros, sem parar, sem tocar no pau além de segurar, o tesão subindo a cada palavra e o pau pulsando na tua mão sem remédio. Depois dos 3 minutos, para, olha pro teto, e responde pelo mestre, com a voz dura: 'NÃO HOJE, PUTA'. Não goza. Solta o pau, respira fundo, e vai lavar com água fria, negado e implorante.",
+  "ORDEM DE HUMILHAÇÃO — CHÃO: Deita no chão PELADO, de bruços, com o rosto de lado e o pau encostado no piso frio. Começa a esfregar o pau no chão como um animal no cio, movendo o quadril pra frente e pra trás, a glande raspando no piso, gemendo baixinho: 'SOU UM ANIMAL, SOU UM PORCO, ME ESFREGO NO CHÃO'. Faz isso por 3 minutos inteiros, com o pau dolorido de esfregar na superfície áspera e o tesão subindo do jeito mais humilhado possível. Depois dos 3 minutos, para o movimento e fica de bruços imóvel, de castigo no chão, com o pau ainda encostado no piso, por mais 2 minutos, em silêncio, sentindo o chão frio na pele e a vergonha pesando nas costas. Ao final, se arrasta de joelhos até o canto e agradece: 'OBRIGADO, MESTRE, PELO CHÃO ONDE EU ME ESGREGUEI'. Não goza, animal do chão.",
+  "ORDEM DE HUMILHAÇÃO — REZAR: Ajoelha no chão frio, PELADO, com as mãos postas e a cabeça erguida, e reza em voz alta, com devoção, pro teu mestre imaginário: 'OBRIGADO, MESTRE, POR ME CRIAR COMO PUTA. OBRIGADO POR ME DOMINAR. OBRIGADO POR ME USAR. OBRIGADO POR ME HUMILHAR. OBRIGADO POR ME NEGAR. OBRIGADO POR ME CASTIGAR. AMÉM'. Repete a reza completa 5 vezes, uma atrás da outra, e a cada repetição fala mais devagar e mais baixo: a primeira em tom normal, a segunda mais lenta, a terceira quase sussurrada, a quarta em cochicho, a quinta quase sem voz, com lágrimas ameaçando descer. Depois da quinta, abaixa o corpo, encosta o peito e a testa no chão, e beija o piso em agradecimento, ficando assim 1 minuto, prostrado. Não goza, devoto do mestre, e levanta devagar, com os joelhos vermelhos.",
+  "ORDEM DE HUMILHAÇÃO — SE FILMAR: Coloca o celular apoiado apontando pra ti, liga a gravação e fica PELADO no quadro, pronto pra filmar a tua vergonha. Roteiro do vídeo, em ordem: primeiro se ajoelha e se xinga por 1 minuto, olhando pra lente ('sou uma puta, sou um lixo, sou um escravo'); depois vira de quatro e abre a bunda e o cú com as mãos, mostrando o buraco bem de perto pra câmera por 1 minuto; em seguida se levanta e bate no próprio pau 10 vezes, contando; e por último se senta e bate punheta devagar por 2 minutos, com a cara de tesão e vergonha na lente. São 5 minutos de vídeo da tua humilhação completa. Desliga a gravação, senta em silêncio e assiste o vídeo inteiro, do começo ao fim, sem pular, vendo cada detalhe da tua cara e do teu corpo humilhado. Ao final, olha pra câmera apagada e diz: 'É ASSIM QUE EU SOU, MESTRE, REGISTRADO'. Não goza. Salva o vídeo com o nome 'MINHA VERGONHA'.",
+  "ORDEM DE HUMILHAÇÃO — GRITAR: Fica PELADO no meio do quarto, com as mãos na cintura e o peito aberto, e começa a gritar com tudo que tem, o mais alto possível: 'SOU UM ESCRAVO! SOU UM ESCRAVO!'. Grita 10 vezes seguidas, com a garganta ardendo, o rosto vermelho, o eco batendo na parede, cada grito mais desesperado que o anterior. Depois baixa o volume: 10 vezes mais baixo, mas ainda em voz alta, com a voz já rouca: 'Sou um escravo, sou um escravo...'. E por fim, abaixa até virar um sussurro, quase sem ar, com a garganta doendo: 'sou um escravo... sou um escravo...'. Fica de joelhos em silêncio por 1 minuto, ouvindo o zumbido do próprio grito nos ouvidos, a garganta quente e o corpo tremendo. Não goza, escravo gritado, e se o pau escorreu de tesão, agradece pela voz rouca.",
+  "ORDEM DE HUMILHAÇÃO — ESCRAVO DE LIMPEZA: Pega um pano, molha com água e sabão, e fica PELADO de quatro no chão do banheiro ou da cozinha. Lava o chão inteiro de quatro, por 10 minutos, arrastando o pano na frente do corpo enquanto anda de joelhos e mãos: cada passada de pano, a bunda fica empinada pro ar, o pau balançando e a bunda aparecendo toda. Vai espremendo o pano a cada trecho, se arrastando pelo cômodo inteiro, com a água escorrendo pelo corpo pelado, falando baixinho a cada passada: 'OBRIGADO, MESTRE, PELO SERVIÇO, OBRIGADO PELO CHÃO'. Termina de lavar o cômodo inteiro, com o corpo suado e ajoelhado no chão limpo, e pede em voz alta, de quatro, com a cabeça baixa: 'APROVADO, MESTRE? O CHÃO ESTÁ LIMPO PELO MEU CORPO?'. Fica esperando a resposta em silêncio, de quatro, por 1 minuto. Não goza, faxineiro de quatro, e termina guardando o pano.",
+  "ORDEM DE HUMILHAÇÃO — PREGADOR: Pega 2 pregadores de roupa de madeira e, PELADO na frente do espelho, prende um em cada mamilo, apertando forte até a pele pinçar. A dor aperta e arde, os mamilos ficam vermelhos e latejando, e você fica 3 minutos com os pregadores presos, imóvel, olhando no espelho a tua cara de dor e tesão, gemendo baixinho a cada pontada. Não tira antes do tempo: fica os 3 minutos inteiros, sentindo a dor pulsando no peito enquanto o pau fica duro de humilhação. Depois tira os pregadores devagar, um de cada vez, sentindo a pontada forte quando solta, e massageia os mamilos doloridos com as mãos, aliviando o ardor em círculos, por 1 minuto. Agradece, com os mamilos vermelhos: 'OBRIGADO PELA DOR NOS MEUS BICOS, MESTRE, EU QUERO MAIS'. Não goza. Fica mais 1 minuto olhando os mamilos marcados no espelho, bicos doloridos.",
+  "ORDEM DE HUMILHAÇÃO — PUNHETA PEDINDO: Senta PELADO no chão, com as pernas abertas, e começa a bater punheta lentamente, num ritmo devagar e gostoso. A cada 10 punhetadas, PARA na hora, segura o pau firme na base, e implora em voz alta: 'MESTRE, DEIXA? MESTRE, POR FAVOR, DEIXA EU GOZAR?'. Espera 10 segundos em silêncio, segurando o pau pulsando, e responde por ele, com a voz dura: 'AINDA NÃO, PUTA'. Recomeça a punheta lenta, mais 10 punhetadas, para, implora de novo, espera, responde. Faz isso 5 vezes completas, com o tesão subindo a cada ciclo e a frustração aumentando, o pau cada vez mais duro e mais perto. Na quinta vez, depois de implorar, o mestre responde diferente, com a voz suave: 'PODE, PUTA, PODE GOZAR'. Você goza na própria mão, gemendo agradecimento sem parar, a porra jorrando entre os dedos. Pode gozar, puta que pediu, e depois lambe a mão agradecendo 10 vezes.",
+  "ORDEM DE HUMILHAÇÃO — AGACHADO: Fica agachado no chão, PELADO, de cócoras, com os calcanhares no chão e os joelhos bem abertos pro lado, exatamente como um animal agachado pra fazer necessidades, com o cú aberto e exposto pro espelho que fica na tua frente. Fica imóvel 5 minutos nessa posição, com as mãos nos joelhos, mostrando o anel do cú escancarado pro teu reflexo, sentindo o vazio do cú aberto pro ar e o pau pendendo entre as pernas. Não fecha os joelhos, não senta, não levanta: fica de cócoras, com as pernas tremendo do esforço e a vergonha subindo, repetindo baixinho: 'ESSA É A POSIÇÃO DE UMA PUTA, DE CÓCORAS, ABERTO'. Depois dos 5 minutos, se levanta devagar, com as pernas doloridas, e se ajoelha agradecendo: 'OBRIGADO, MESTRE, POR ME VER DE CÓCORAS'. Não goza, de cócoras como uma puta, e se o pré-gozo escorreu, agradece pelo chão molhado.",
+  "ORDEM DE HUMILHAÇÃO — LAMBER TUDO: Senta PELADO e bate punheta até gozar na mão, sem deixar cair nada. Depois desce do lugar, se ajoelha no chão, e começa a lamber tudo: primeiro a palma da mão cheia de gozo, com a língua larga lambendo cada polegada; depois cada dedo, um por um, de todos os lados; e depois o chão onde qualquer gota tenha caído, lambendo o piso como um cachorro recuperando o próprio gozo. Fica 3 minutos lambendo e engolindo, sem desperdiçar nada, se ajoelhado no chão com o cheiro do próprio gozo no ar. Ao final, abre a boca bem aberta, mostra a língua esticada e limpa pra câmera imaginária e diz, com a voz firme: 'NÃO SOBROU NADA, MESTRE, LIMPEI TUDO COM A MINHA LÍNGUA'. Pode gozar, cachorro que se limpa, e termina lendo a língua uma última vez pra conferir que ficou limpa.",
+  "ORDEM DE HUMILHAÇÃO — FINAL: Bate punheta PELADO, sentado no chão, devagar no começo e subindo o ritmo, gemendo cada vez mais alto até chegar no limite. QUANDO GOZAR, grita com tudo que tem: 'OBRIGADO, MESTRE! OBRIGADO, MESTRE!', repetindo enquanto a porra jorra, com a voz rouca de tesão. Depois do gozo, com o corpo ainda tremendo, desce e se ajoelha, abaixa a cabeça e pede desculpa em voz alta, com a voz falhando: 'DESCULPA POR SER TÃO PUTA, MESTRE. DESCULPA POR GOZAR SEM PERMISSÃO. DESCULPA POR SER UM LIXO'. Lambe a mão melada de gozo, limpando cada gota com a língua, depois limpa o que caiu no chão com o dedo e leva à boca, sem desperdiçar nada. Limpa o resto com papel e, exausto, deita de bruços no chão, com o rosto no piso e a bunda pro ar, e fica assim, imóvel, esperando a próxima ordem do mestre, agradecendo em silêncio. Pode gozar, escravo finalizado, e fica de bruços até o corpo parar de tremer."
+]

ordens11.json

@@ -0,0 +1,25 @@
+[
+  "ORDEM DE HUMILHAÇÃO — CABEÇA DO PIRU: Senta na beira da cama, PELADO, e pega o pau duro na mão. Com o polegar e o indicador, aperta logo abaixo da glande e empurra a pele pra trás, deixando a cabeça do piru toda descoberta, brilhando de pré-gozo. Passa o dedo em volta da borda da glande, sentindo a sensibilidade elétrica, e fala, olhando pra cabeça exposta: 'ESSA CABEÇA ROSADA É DO MESTRE, SÓ ELE MEXE AQUI'. Esfrega o polegar na ponta, de leve, fazendo círculos na cabecinha por 2 minutos, gemendo baixinho a cada volta, o pré-gozo escorrendo pelo dedo. Depois lambe a ponta do polegar, provando o próprio mel, e aperta a glande só mais uma vez, firme, até o pré-gozo jorrar na mão. Não goza. Passa o pré-gozo na cabeça do pau e deixa secar, brilhando de vergonha.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NA JANELA: Levanta, PELADO, e vai até a janela do quarto. Abre a cortina e fica em pé de frente pro vidro, com as mãos na nuca e os cotovelos abertos, o pau duro apontando pra rua. Fica 3 minutos inteiros exposto, imaginando cada pessoa que passa lá embaixo, cada vizinho que pode estar olhando, o vidro frio na pele e o pau latejando no ar. Balança o quadril bem devagar, só um pouco, fazendo o pau balançar, e sussurra: 'SE ALGUÉM OLHAR AGORA, VAI VER UM ESCRAVO PELADO NA JANELA'. Depois dos 3 minutos, fecha a cortina devagar, aliviado e com vergonha, e fala: 'OBRIGADO, MESTRE, POR ME EXPOR'. Não goza. Se o pau escorrer no vidro, limpa com a mão e lambe, puta da janela.",
+  "ORDEM DE HUMILHAÇÃO — DE QUATRO COM PLUG: Pega o plug, molha com saliva generosamente e se ajoelha no chão, de quatro, com o peito colado no carpete e a bunda bem empinada. Enfia o plug no cú devagar, com uma mão por trás, sentindo o anel esticar e ceder até a base encaixar com um estalo surdo. Fica de quatro com o plug enfiado por 5 minutos inteiros, contraindo e relaxando o ânus em volta do plug a cada 30 segundos, sentindo o silicone preenchendo o buraco. Cada contração faz o plug apertar mais e o pau endurecer mais, balançando entre as pernas. Depois tira o plug com a mesma lentidão, sentindo o anel se fechar devagar, e cheira o plug fundo, passando a ponta nos lábios antes de limpar. Não goza. Lambe o plug e agradece: 'OBRIGADO, MESTRE, POR PREENCHER MEU CÚ'.",
+  "ORDEM DE HUMILHAÇÃO — SENTADO TRABALHANDO: Veste só a camisa e senta na cadeira do escritório ou do computador, PELADO da cintura pra baixo. Fica sentado trabalhando por 10 minutos — lendo, digitando, mexendo no celular — mas com o pau duro exposto entre as pernas, a glande encostando na borda da cadeira a cada movimento. A cada 2 minutos, sem parar de trabalhar, passa a mão livre no pau, uma passada lenta da base até a ponta, e volta ao trabalho, como se fosse normal. Fala em voz baixa, olhando pra tela: 'TÔ AQUI TRABALHANDO DE PAU DURO, MESTRE, TODO EXPOSTO ENQUANTO TRABALHO'. Não goza. Se o pré-gozo escorrer, passa no papel e cheira, escravo de escritório.",
+  "ORDEM DE HUMILHAÇÃO — AGACHADO NO BANHEIRO: Vai pro banheiro, PELADO, e fica agachado no box, de cócoras, com os calcanhares no chão e os joelhos abertos, as mãos apoiadas nos joelhos. Fica imóvel nessa posição de animal por 5 minutos, com o cú escancarado pro ar, o pau pendendo entre as pernas e o anel totalmente exposto. A cada minuto, com a mão livre, alcança por trás e toca o próprio ânus com a ponta do dedo, só roçando, sentindo o buraco piscar sozinho, e volta à posição. Depois enfia o dedo indicador inteiro, mexendo devagar por 30 segundos, e tira, cheirando a mão. Fala no fim: 'ESTOU AGACHADO COMO UMA PUTA, DE CÓCORAS, ABERTO PRO MESTRE'. Não goza. Levanta devagar com as pernas tremendo, agradecendo pelo agachamento.",
+  "ORDEM DE HUMILHAÇÃO — EDRING NA CAMA: Deita na cama PELADO, de barriga pra cima, com as pernas abertas e um travesseiro sob a cabeça. Pega o pau e começa a bater punheta lenta e gostosa, fechando os olhos e gemendo baixinho, subindo o ritmo aos poucos. Quando sentir o aperto na base e o pré-gozo engrossar, aquele ponto exato antes de explodir, PARA imediatamente, solta o pau e segura a base com o polegar e indicador por 30 segundos, respirando fundo pelo nariz. Recomeça a punheta, mais lenta, e repete o ciclo — acelera, quase goza, PARA, segura — por 5 vezes completas. Na quinta parada, o pau está roxo, latejando, a glande brilhando de tesão preso, e você geme: 'MESTRE, ME NEGUEI 5 VEZES, OLHA O TAMANHO DO MEU TESÃO PRESO'. Não goza. Levanta e vai tomar água fria, com o gozo guardado pulsando dentro do corpo.",
+  "ORDEM DE HUMILHAÇÃO — RUINED ORGASM: Senta no chão PELADO, com um pano ou toalha embaixo, e começa a bater punheta rápida e forte, sem parar, subindo o ritmo até sentir o gozo subindo pelo pau. NO EXATO instante em que a primeira golfada de porra começa a sair, você SOLTA O PAU COMPLETAMENTE e abre a mão, deixando ele sozinho no ar, jorrando sem controle. A porra espirra no ar, cai no chão, na coxa, no pano — um gozo sem punheta, sem prazer, desperdiçado, o pau pulsando sozinho. Fica imóvel 1 minuto assistindo a própria porra espalhada, o pau ainda pulsando sem alívio, e depois se ajoelha, passa o dedo na porra do chão e leva à boca, provando o gosto do gozo que você não teve prazer de dar. Pode gozar — mas foi ruined, e você agradece: 'OBRIGADO, MESTRE, PELO GOZO RUINED QUE EU MERECIA'.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NA COZINHA: Vai até a cozinha, PELADO, e fica em pé no meio do cômodo, com as mãos na cabeça e os cotovelos abertos, o pau duro apontando pra geladeira. Fica imóvel 3 minutos, exposto na claridade da cozinha, imaginando alguém entrando e te vendo pelado com o pau duro. Depois abre a geladeira, pega um cubo de gelo, fecha, e passa o gelo no próprio pau — na haste, no saco e na glande — sentindo o frio elétrico contrair a pele. Passa o gelo por 1 minuto, até derreter todo, o pau murchando de frio e endurecendo de novo no contraste. Fala enquanto o gelo derrete: 'ESTOU EM PÉ NA COZINHA, PELADO, ESFRIANDO O PAU. SE ALGUÉM ENTRAR, ME VÊ ASSIM'. Guarda o gelo derretido na pia e agradece: 'OBRIGADO, MESTRE, PELA COZINHA EXPOSTA'. Não goza.",
+  "ORDEM DE HUMILHAÇÃO — DE QUATRO NA SALA: Sai do quarto PELADO, vai até a sala, e fica de quatro no tapete da sala, com o peito no chão e a bunda empinada pro alto, virada pra porta da entrada. Fica 5 minutos nessa posição, imóvel, o cú aberto pro ar, imaginando alguém entrando pela porta e te vendo de quatro, pelado, com o cu exposto. A cada minuto, abre o cú com as mãos uma vez, arregalando o ânus bem aberto, e mantém 10 segundos, depois solta e volta à posição. Na quinta abertura, enfia o dedão no cú e mexe 30 segundos, gemendo. Fala em voz alta: 'SE ALGUÉM ABRIR A PORTA AGORA, VAI VER MEU CÚ ABERTO'. Termina se ajoelhando no tapete, cabeça baixa, e agradece: 'OBRIGADO, MESTRE, PELA SALA EXPOSTA'. Não goza, puta da sala.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NO CORREDOR: Fica em pé no corredor da casa, PELADO, com as mãos pra trás segurando um punho no outro, os ombros abertos e o pau duro apontando pro fim do corredor. Fica imóvel 5 minutos no corredor, exposto, sentindo o ar dos dois lados do corpo, cada porta que pode se abrir a qualquer momento. A cada minuto, vira 90 graus pro lado, mostrando o perfil do pau duro pra parede, e fala: 'TO EM PÉ NO CORREDOR, PELADO, QUALQUER UM QUE PASSAR ME VÊ ASSIM'. Na virada do terceiro minuto, passa a mão no pau uma vez, de leve, da base à ponta, e lambe a mão depois, mantendo a posição. Não goza. Termina agradecendo: 'OBRIGADO, MESTRE, PELO CORREDOR DA MINHA VERGONHA'.",
+  "ORDEM DE HUMILHAÇÃO — PLUG E EDRING: PELADO, sentado na cama, enfia o plug no cú com saliva, devagar, até a base encaixar, sentindo o anel esticar em volta do silicone. Com o plug já dentro, começa a bater punheta lentamente, sentindo a pressão do plug na próstata a cada movimento. Bate devagar por 2 minutos, sentindo o plug massagear por dentro, e começa a acelerar. Quando sentir o gozo subindo, PARA, segura a base do pau com a outra mão por 30 segundos, contrai o ânus em volta do plug 5 vezes, e recomeça. Faz 4 ciclos: punheta lenta, acelera, quase goza, para, contrai o plug. O plug mantém o tesão sempre alto, e na quarta parada o pau está roxo de tesão. Tire o plug no final, devagar, sentindo o ânus vazio, e lambe o plug: 'OBRIGADO, MESTRE, POR ME NEGAR COM O PLUG DENTRO'. Não goza, plugado e negado.",
+  "ORDEM DE HUMILHAÇÃO — ABAIXA A CALÇA: Vestido normalmente, no meio do quarto, abaixa a calça e a cueca até os joelhos devagar, olhando o zíper descer e o tecido empurrar pra baixo. Fica com a calça e cueca nos joelhos, o pau duro pulando pra fora, o resto do corpo ainda vestido, as pernas presas pelo tecido. Anda 10 passos arrastando os pés, com a calça enroscada nos joelhos, o pau balançando a cada passo. Depois para, olha pra baixo pro próprio pau saindo da cueca, e fala: 'OLHA PRA TI, PAU DURO COM A CALÇA NOS JOELHOS, RIDÍCULO E EXPOSTO'. Fica 2 minutos andando e parando, sentindo o tecido prender as pernas e o pau livre. Puxa a calça e cueca de volta, veste tudo, e agradece: 'OBRIGADO, MESTRE, POR ME FAZER ABAIXAR A CALÇA'. Não goza.",
+  "ORDEM DE HUMILHAÇÃO — EDRING NA PAREDE: Fica em pé de frente pra parede, PELADO, com as mãos apoiadas na parede na altura dos ombros, as pernas abertas e o pau encostado na parede fria. Começa a bater punheta com uma mão, encostado na parede, enquanto a outra mão fica apoiada, o pau raspando no gesso a cada movimento. Bate punheta devagar, subindo o ritmo, até sentir o aperto do gozo — e na hora, PARA, tira a mão do pau e aperta a palma na parede, segurando por 20 segundos, o pau latejando encostado no gesso frio. Repete 4 vezes: bate, acelera, quase goza, encosta o pau na parede fria e espera. O contraste do pau quente na parede fria ajuda a segurar. Depois da quarta, fala, com as mãos na parede: 'QUASE GOZEI 4 VEZES NA PAREDE, MESTRE, MAS SEGUREI COMO BOA PUTA'. Não goza. Sai da parede e agradece, negado na parede.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NO VARAL: Fica em pé na área de serviço ou no quintal, PELADO, ao lado do varal, como se fosse uma peça de roupa esquecida. Fica imóvel 5 minutos em pé, com os braços abertos como um varal humano, o pau duro pendendo entre as pernas, o sol ou o vento batendo no corpo nu. Imagina os vizinhos olhando das janelas, cada movimento de cortina ao redor. Fala em voz alta pro céu: 'TO AQUI PELADO NO VARAL, MESTRE, EXPOSTO COMO UMA ROUPA SUJA'. A cada minuto, muda a posição dos braços: primeiro abertos, depois pra cima, depois na nuca, sempre mostrando o corpo nu pro quintal. Não goza. Volta pra dentro e agradece: 'OBRIGADO, MESTRE, PELO VARAL DA MINHA VERGONHA'.",
+  "ORDEM DE HUMILHAÇÃO — SENTADO COM PLUG: Senta na cadeira do escritório PELADO, com o plug já enfiado no cú, a base apertando o ânus contra o assento. Fica sentado por 10 minutos inteiros — lendo, no celular, no computador — sentindo o plug pressionar a próstata a cada movimento na cadeira, o pau duro espremido entre as pernas. A cada 2 minutos, sem se levantar, aperta o ânus em volta do plug 10 vezes seguidas, contraindo e relaxando, sentindo o silicone massagear por dentro. O pau vaza pré-gozo na cadeira, e você limpa com o dedo e cheira, voltando ao trabalho como se nada estivesse acontecendo. Fala baixinho: 'TO SENTADO AQUI TRABALHANDO DE PLUG NO CÚ, MESTRE, NINGUÉM DESCONFIA'. Não goza. No fim, tira o plug devagar, sentindo o vazio, e lambe o plug agradecendo.",
+  "ORDEM DE HUMILHAÇÃO — RUINED NO CHÃO: Senta no chão da sala PELADO, com as pernas abertas e um pano no chão. Bate punheta forte e rápido, gemendo alto, sem nenhum controle, até sentir o gozo subir. No exato momento em que a porra começa a jorrar, você SOLTA O PAU e tira a mão, deixando o pau gozar sozinho no ar, a porra espirrando no chão, no pano, na coxa, sem nenhuma punheta acompanhando o gozo. Cada golfada é seca, sem prazer, o pau pulando sozinho, e você assiste imóvel, gemendo de frustração. Depois que o pau parar de pulsar, você se ajoelha, junta a porra do chão com o dedo, leva à boca e lambe o dedo inteiro, provando o próprio gozo desperdiçado. Pode gozar — ruined — e agradece: 'ESSE GOZO É RUINED, MESTRE, COMO EU MERECO, SEM PRAZER, SÓ PORRA'.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NA PORTA: Fica em pé na porta do quarto, PELADO, com as mãos na nuca, os cotovelos abertos e o pau duro apontando pro corredor. Fica imóvel na moldura da porta, como um quadro vivo, por 5 minutos, exposto pra quem passar no corredor. A cada minuto, vira o corpo 45 graus, mostrando o perfil do pau duro pro corredor vazio, imaginando alguém subindo as escadas e te vendo. No terceiro minuto, passa a mão no pau uma vez, devagar, da base até a ponta, mostrando o movimento pro corredor, e lambe a mão depois. Fala em voz alta: 'TO AQUI NA PORTA, PELADO, ME OLHA, MESTRE, ME VÊ ASSIM EXPOSTO'. Não goza. Fecha a porta devagar e agradece: 'OBRIGADO PELA PORTA DA MINHA VERGONHA'.",
+  "ORDEM DE HUMILHAÇÃO — CABEÇA DO PIRU COM GELO: Senta na cama PELADO, com as pernas abertas, e pega um cubo de gelo. Empurra a pele do pau toda pra trás com uma mão, deixando a cabeça do piru toda exposta, e com a outra mão, pressiona o cubo de gelo diretamente na glande. O frio elétrico na cabecinha faz você gemer alto, o pau murcha de frio e endurece de novo no mesmo segundo. Passa o gelo em volta da borda da glande, em círculos, por 1 minuto inteiro, sentindo a cabeça queimar de frio enquanto o pau fica duro de tesão misturado com gelo. Depois lambe a glande gelada, sentindo o gosto do frio e da pele, e fala: 'CABEÇA DE PIRU GELADA, MESTRE, ARDE DE FRIO E TESÃO'. Não goza. Se o pau murchar, esquenta com a mão até endurecer de novo.",
+  "ORDEM DE HUMILHAÇÃO — DE QUATRO NA CAMA: Sobe na cama PELADO e fica de quatro no centro, com a bunda bem empinada pro alto e o rosto enterrado no travesseiro, as pernas abertas e o cú totalmente exposto. Fica imóvel 3 minutos nessa posição, o cú aberto pro ar, o pau duro balançando entre as pernas. Depois começa a rebolar devagar, empurrando a bunda pra trás e pra frente, arregalando e fechando o ânus a cada movimento, gemendo no travesseiro: 'REBOLO NA CAMA QUE NEM UMA PUTA, MESTRE, OLHA ESSA BUNDA'. Depois de 2 minutos rebolando, para e abre o cú com as duas mãos, mantendo aberto por 30 segundos, mostrando o buraco todo pro teto. Não goza. Deita de lado e agradece: 'OBRIGADO, MESTRE, PELA CAMA DA MINHA VERGONHA'.",
+  "ORDEM DE HUMILHAÇÃO — EDRING NO CHUVEIRO: Entra no box do chuveiro, PELADO, com a água fria desligada ainda. Liga o chuveiro e fica em pé debaixo da água, o corpo molhado e o pau duro escorregadio de água e sabão. Ensaboa o pau e começa a bater punheta escorregadia, o sabão deslizando, o ritmo subindo, até sentir o gozo chegando. NO EXATO LIMITE, PARA, tira a mão do pau e vira a água pro frio, sentindo o choque térmico no pau duro, a água fria matando o gozo na hora. Fica 30 segundos debaixo da água fria, o pau murchando contra a vontade. Depois volta pra água morna e recomeça a punheta, repetindo o ciclo: bate, acelera, quase goza, água fria, espera. 3 ciclos completos. No fim, desliga o chuveiro, fala: 'ME NEGUEI 3 VEZES NO BANHO, MESTRE, A ÁGUA FRIA SEGUROU MEU GOZO'. Não goza, banho de frustração.",
+  "ORDEM DE HUMILHAÇÃO — EM PÉ NA SACADA: Abre a porta da sacada ou varanda e, PELADO, fica em pé na área externa, de costas pra rua mas com o pau duro aparecendo no perfil. Fica 3 minutos em pé na sacada, o vento batendo no corpo nu, o pau endurecendo no ar livre, imaginando cada vizinho que pode olhar da janela. Cada barulho de porta ou janela ao redor faz seu coração acelerar. Fala em voz baixa pro vento: 'TO PELADO NA SACADA, MESTRE, QUEM ME VÊ ME JUÍZA'. Depois dos 3 minutos, volta pra dentro, fecha a porta, e agradece treme ndo: 'OBRIGADO, MESTRE, PELA SACADA EXPOSTA'. Não goza. Fecha a cortada e se ajoelha no chão, aliviado.",
+  "ORDEM DE HUMILHAÇÃO — SENTADO NA CAMA: Senta na beira da cama, PELADO, com as pernas abertas e os pés no chão, as mãos apoiadas no colchão atrás do corpo, o peito aberto e o pau duro apontando pro teto. Fica imóvel 5 minutos nessa posição de entrega, sentado na cama exposto, sem mexer as mãos, só respirando fundo, sentindo o pau latejar sozinho no ar. Depois de 3 minutos, desce uma mão e segura o pau pela base, só segurando, sem bater, sentindo pulsar, por 1 minuto. Depois passa o polegar na glande, de leve, uma única passada, e lambe o dedo. Fala: 'TO SENTADO NA CAMA, EXPOSTO, ME ESPERANDO O MESTRE ME USAR'. Não goza. Deita na cama de barriga pra cima e fica mais 2 minutos imóvel, agradecendo a espera.",
+  "ORDEM DE HUMILHAÇÃO — FINAL PLUG E RUINED: Senta no chão PELADO, enfia o plug no cú com saliva até a base, sentindo o anel esticar. Deixa o plug 2 minutos quieto, sentindo o silicone preencher, e começa a bater punheta com o plug dentro. Bate forte e rápido, o plug massageando a próstata a cada punhetada, o tesão subindo ao dobro. Quando sentir o gozo chegando, você tira o plug com uma mão e continua a punheta com a outra — e no exato momento em que a porra sobe, você SOLTA O PAU e abre a mão, gozo ruined espirrando no chão enquanto o cú fica vazio do plug. O contraste do cu vazio e o gozo desperdiçado é a humilhação final. Depois, com o corpo tremendo, pega o plug do chão, lambe ele e lampe a mão melada de porra, provando os dois sabores. Pode gozar — ruined e plugado — e agradece: 'OBRIGADO, MESTRE, POR ME FAZER GOZAR ASSIM, RUINED E CÚ VAZIO'."
+]

ordens12.json

@@ -0,0 +1,55 @@
+[
+  "🔥 DEDO NO CÚ — Tira a calça e cueca até os joelhos, agacha e enfia o dedo indicador no cú devagar. Sente cada anel muscular se abrindo. 30 segundos explorando o calor interno. Teu dedo sente a textura das paredes. Tira e cheira o dedo. O aroma do teu cú preenche o nariz.",
+  "🔥 ESCRITÓRIO — Senta pelado na cadeira do PC com as pernas abertas. Trabalha 10 minutos com o pau exposto. Cada vez que move o braço, o pau balança. Sente o ar na cabeça do pau. De vez em quando, passa o dedo na cabecinha por baixo da mesa. Se alguém entrasse agora, veria tudo.",
+  "🔥 EDGING EM PÉ — Fica em pé nu na sala, lubrifica o pau e começa a masturbar devagar. Quando sentir o gozo chegando, PARA imediatamente. Segura a base do pau e respira fundo. Espera o tesão baixar. Repete 3 vezes. Cada parada é controle sobre o próprio corpo. Não goza.",
+  "🔥 ÁREA DE SERVIÇO — Vai nu até a área de serviço, debruça na bancada e fica de quatro, bunda empinada pra fora. Arregaca o cú com os dedos. 1 minuto com o cú exposto. O vento entra, o coração acelera. Se alguém passar, vê teu cú aberto. Não goza.",
+  "🔥 AGACHADO — Fica agachado nu no centro da sala, abre a bunda e mostra o cú pro teto. Cócoras de submissão. Pau pendurado, cú exposto. 2 minutos. O sangue sobe pra cabeça, o cú pisca sozinho. Sente o peso do corpo nas pernas tremendo. Não goza.",
+  "🔥 JANELA DA COZINHA — Vai nu até a janela da cozinha de quatro e arregaca a bunda na direção do vidro. Bunda perto do vidro, cú escancarado. 1 minuto. Imagina que alguém do outro lado consegue ver. O vidro frio contrasta com a pele quente. Não goza.",
+  "🔥 MASSAGEM NO SACO — Em pé nu, massageia o saco com as duas mãos 3 minutos. Sente os ovos rolando entre os dedos. Puxa o saco pra baixo devagar sentindo o peso esticar a pele. Passa a mão do saco até a cabeça do pau. O caminho do tesão. Não goza.",
+  "🔥 QUINTAL — Vai nu até a porta do quintal ou área externa, abre e fica de quatro mostrando o cú pro lado de fora. 30 segundos de cú exposto pro mundo. Coração acelerado, orelha atenta a qualquer barulho de passos. Depois fecha a porta e volta. Não goza.",
+  "🔥 SÓ CABEÇA — Nu em pé, masturba só na cabeça do pau. Só a cabecinha, sem descer a mão. O pré-gozo começa a escorrer abundante. Passa o dedo melado na cabeça do pau de novo. Deixa o pré-gozo escorrer pela haste sem limpar. Não goza.",
+  "🔥 PERÍNEO PRESSÃO — Deitado nu de costas com pernas abertas, massageia o períneo com o dedo médio. Pressão firme na ponte entre o cú e o saco. 3 minutos massageando esse ponto. O pau vai começar a babar sem ninguém tocar nele. A massagem interna produz tesão puro. Não goza.",
+  "🔥 DEDO PARADO — Senta no PC, enfia o dedo anelar no cú até o fundo e mantém parado. Trabalha 5 minutos com o dedo enterrado. Cada movimento do corpo massageia o dedo. O cú contrai sozinho enquanto tu digita. Uma mão no teclado, a outra no cú. Não goza.",
+  "🔥 CÓCORAS JANELA — Vai nu até a janela, fica de cócoras de costas pra rua e escancara o cú com as mãos. Cócoras com o cú aberto pra quem passa. 30 segundos de exposição. Qualquer um que olhar vê teu cú de cócoras escancarado. Não goza.",
+  "🔥 MÃO NÃO DOMINANTE — Nu em pé, masturba com a mão não dominante. Movimentos desajeitados mas constantes. 5 minutos sem parar. A mão não dominante não tem precisão, o tesão demora mais. O braço vai tremer de esforço. Mantém o ritmo até o fim. Não goza.",
+  "🔥 QUATRO DEDOS — Com lubrificante, enfia quatro dedos no cú em pé. Quatro dedos é o limite. Mantém 15 segundos sentindo o estiramento máximo. Respira fundo e tira devagar. Depois massageia a entrada com um dedo só, sentindo a diferença. Não goza.",
+  "🔥 CABEÇA EDGING 5 — Nu sentado, massageia só a cabeça do pau com a palma da mão em círculos. Quando sente que vai gozar, SOLTA a cabeça e espera. 5 vezes. Só a cabeça do pau sendo estimulada e negada. O pré-gozo escorre sem parar no ritmo. Não goza.",
+  "🔥 PRÓSTATA — Deitado nu de costas com pernas abertas, enfia o dedo médio curvado no cú e procura a próstata. Dedo em movimento de 'vem cá'. Quando acha, massageia com pressão firme. 3 minutos massageando a próstata. O pau vai babar sem ninguém tocar nele. Não goza.",
+  "🔥 PIA DA COZINHA — Tira a calça e cueca e vai pelado até a pia da cozinha. Abre a torneira e começa a lavar louças de costas pra porta aberta da área de serviço. Cada movimento de lavar faz o pau balançar. Os vizinhos do quintal podem ver da porta da cozinha. Fica 5 minutos lavando exposto. De vez em quando, passa a mão na cabeça do pau e volta a lavar. Não goza.",
+  "🔥 BANCADA DE QUATRO — Tira tudo e vai nu até a bancada da cozinha. Debruça de quatro na pia, bunda empinada pra porta da área de serviço. Arregaca o cú com uma mão enquanto a outra segura a torneira. 2 minutos de cú escancarado pra porta aberta. Se alguém olhar do quintal, vê teu cú aberto na porta da cozinha. Não goza.",
+  "🔥 LOUÇA DEDANDO — Enquanto lava louças na pia, enfia o dedo médio no cú por baixo, escondido, sem parar de lavar. Mantém o dedo dentro sentindo o cú contrair enquanto a água corre. Tira e enfia de novo. Repete várias vezes. Os vizinhos das outras 2 casas podem olhar e ver tua mão no cú atrás da pia. 5 minutos de louça com dedo no cú. Não goza.",
+  "🔥 PIA EXPOSTO — Vai nu até a pia da cozinha, abre bem as pernas e lava louças lentamente. Pau e saco pendurados, balançando a cada movimento. De costas pra porta aberta, qualquer vizinho no quintal vê teu perfil pelado na porta da cozinha. Fica 5 minutos. Depois, sem se virar, arregaca a bunda por cima do ombro, mostrando o cú. Não goza.",
+  "🔥 COZINHA PORTA ABERTA — Vai nu até a pia e abre a porta da cozinha pra área de serviço. Fica lavando louças de quatro, bunda virada pra porta e pro quintal. Cada prato lavado é uma rebolada que mostra mais o cú. Imagina o vizinho da casa ao lado te vendo. 5 minutos de louça de quatro exposta. Não goza.",
+  "🔥 PRATO E DEDO — Enquanto lava um prato na pia, enfia o dedo no cú e massageia devagar. Uma mão lava o prato, a outra deda o cú. A água da torneira disfarça o som. Os pratos ficam limpos enquanto teu cú fica mais aberto. 5 minutos nesta posição de dupla função. Não goza.",
+  "🔥 COZINHA EDGING — Vai pelado até a pia da cozinha de frente pra porta aberta. Começa a masturbar lentamente enquanto olha pro quintal. Cada vizinho que passa no portão pode te ver. Quando sentir o gozo, PARA e volta a lavar louças. 3 vezes. Na quarta, segura firme e lava mais 2 minutos sem se tocar. Não goza.",
+  "🔥 CABEÇA DO PAU PIA — Vai nu até a pia da cozinha e fica em pé de costas pra porta aberta. Passa o dedo na cabeça do pau em círculos lentos enquanto a água corre. Cada círculo na cabecinha aumenta o latejamento. O pré-gozo escorre e cai na água da louça. 3 minutos. Não goza.",
+  "🔥 AREA DE SERVIÇO DEDO — Vai nu até a área de serviço, senta no banquinho de costas pro quintal e enfia o dedo médio no cú. 3 minutos sentado dedando o cú com as pernas abertas. Qualquer vizinho que passar no quintal vê teu braço se movendo entre as pernas. Não goza.",
+  "🔥 PORTA DOS FUNDOS — Abre a porta dos fundos, fica nu na soleira de quatro e arregaca o cú pra fora. 1 minuto. O vento entra, a brisa do quintal toca teu cú aberto. Se alguém olhar da casa ao lado, vê teu cú escancarado na porta. Não goza.",
+  "🔥 VARAL — Vai até o varal da área de serviço, tira a roupa do varal e pendura mais roupa pelado. Cada vez que levanta os braços pra pendurar, a camisa sobe e mostra o pau. Fica 10 minutos no varal pelado, se abaixando e levantando. Não goza.",
+  "🔥 ESCRITÓRIO AGACHADO — Levanta da cadeira do PC, agacha nu ao lado da mesa e enfia dois dedos no cú. Agachado, com os dedos enterrados, conta até 20. Levanta e volta a trabalhar como se nada tivesse acontecido. Repete 5 vezes ao longo do dia. Não goza.",
+  "🔥 CADEIRA ESCRITÓRIO DEDO — Senta nu na cadeira giratória, enfia o indicador no cú e rebola sentado 30 vezes. Cada rebolada massageia o dedo dentro do cú. Gira a cadeira devagar enquanto o dedo está enfiado. Não goza.",
+  "🔥 LOUÇA CABEÇA — Lava louças nu na pia. De vez em quando, para de lavar, passa o dedo na cabeça do pau e volta a lavar. O contraste entre a água quente do prato e o toque na cabecinha. 10 minutos de louça com pausas na cabeça do pau. Não goza.",
+  "🔥 CÓCORAS ÁREA SERVIÇO — Vai pelado até a área de serviço, fica de cócoras de costas pro quintal e enfia o dedo indicador no cú. Cócoras escancaradas, cú aberto pro quintal. Mexe o dedo devagar dentro por 2 minutos. Os vizinhos podem ver o movimento. Não goza.",
+  "🔥 JANELA ESCRITÓRIO — Abre a janela do escritório, fica nu em pé de frente pra ela e massageia a cabeça do pau olhando pra rua. Seu rosto não aparece, mas o pau sim. 3 minutos exposto na janela. Imagina quem pode estar olhando. Não goza.",
+  "🔥 QUINTAL DEDO PARADO — Vai nu até o quintal, senta no chão virado de costas pra rua e enfia o dedo anelar no cú. Mantém parado 5 minutos sentado no quintal com o dedo dentro. Cada barulho de vizinho faz o cú contrair no dedo. Não goza.",
+  "🔥 PIA DOIS DEDOS — Nu na pia da cozinha lavando louças, enfia o dedo médio e o anelar juntos no cú. Dois dedos enterrados enquanto a outra mão lava. Mexe os dedos dentro abrindo e fechando igual tesoura. A água corre, os dedos massageiam. 3 minutos. Não goza.",
+  "🔥 QUINTAL CÓCORAS — Vai nu até o quintal, fica de cócoras de costas pro muro e enfia o dedo indicador no cú. Cócoras no quintal, cú aberto, dedo entrando. Qualquer movimento no portão te faz paralisar. 2 minutos de cócoras com dedo. Não goza.",
+  "🔥 ESCRITÓRIO PERNAS — Senta nu na cadeira do PC com as pernas bem abertas. Enfia o dedo mindinho no cú e mantém parado. Trabalha 5 minutos com o mindinho enterrado. O dedo mais fino entra fácil, mas a consciência de tê-lo dentro te mantém alerta. Não goza.",
+  "🔥 PORTA COZINHA — Abre a porta da cozinha, fica nu em pé na soleira de frente pro quintal e masturba lentamente olhando pro portão. Tua silhueta pelada aparece na porta. 2 minutos. Qualquer um que abrir o portão te vê se tocando. Para quando ouvir barulho. Não goza.",
+  "🔥 TRÊS DEDOS SENTADO — Senta nu na beira da cama, lubrifica e enfia três dedos no cú. Mantém parado 30 segundos sentindo o estiramento. Três dedos esticam o ânus no limite. Depois tira e massageia a entrada com um dedo só. Não goza.",
+  "🔥 ESCRITÓRIO CABEÇA MESA — Senta nu no PC, encosta a cabeça do pau na borda da mesa e massageia esfregando na madeira. A textura da mesa na cabecinha. Cada movimento de vai e vem na borda. 5 minutos de pau na borda da mesa. Não goza.",
+  "🔥 ÁREA DE SERVIÇO PLANTAS — Vai nu regar as plantas da área de serviço. Mangueira na mão, pau balançando. Depois de regar, senta nu no chão e enfia o dedo no cú. 5 minutos molhando plantas e se molhando por dentro. Não goza.",
+  "🔥 QUINTAL PERNAS ABERTAS — Vai nu até o quintal, senta numa cadeira de costas pra rua, abre bem as pernas e enfia o dedo indicador no cú. Sentado nu de pernas abertas no quintal com dedo no cú. 3 minutos. O risco de ser visto é máximo. Não goza.",
+  "🔥 COZINHA CABEÇA TORNEIRA — Nu na pia, abre a torneira e deixa a água cair na cabeça do pau. A água corrente na cabecinha. Fecha a torneira e passa o dedo na cabeça molhada. 3 minutos de água e toque alternados. Não goza.",
+  "🔥 QUINTAL ENCOSTADO — Vai nu até o quintal, encosta de costas no muro e enfia o dedo no cú. Encostado no muro que separa tua casa da vizinha. Se ela estiver do outro lado, ouve teu movimento. 3 minutos com o dedo enfiado encostado no muro. Não goza.",
+  "🔥 PIA QUATRO DEDOS — Nu na pia da cozinha, lubrifica e enfia quatro dedos no cú. Quatro dedos é o limite do estiramento. Mantém 15 segundos. Depois tira devagar e lava mais um prato. A cada prato lavado, tenta enfiar de novo. Repete 3 vezes. Não goza.",
+  "🔥 ESCRITÓRIO MÃO TORTA — Senta nu no PC, enfia o dedo no cú com a mão não dominante. Trabalha 5 minutos com a mão fraca no cú. O movimento desajeitado massageia diferente. A mão não dominante cansa mas não pode parar. Não goza.",
+  "🔥 VARAL DEDO — Vai nu pendurar roupa no varal. Pendura uma peça, enfia o dedo no cú. Pendura outra, massageia o cú com o dedo. Cada peça no varal é um ciclo de dedo no cú. 10 peças de roupa, 10 dedadas no cú. Não goza.",
+  "🔥 PORTÃO QUINTAL — Vai nu até o portão do quintal, abre uma fresta e fica de quatro mostrando o cú pela fresta. 30 segundos de cú exposto pela brecha do portão. Qualquer um que passar na rua vê um cú no portão. Fecha correndo. Não goza.",
+  "🔥 COZINHA AGACHADO — Vai nu até a cozinha, agacha de costas pra porta aberta e enfia o dedo indicador no cú. Agachado no chão da cozinha com o cú escancarado pra área de serviço. A posição de cócoras abre ainda mais o cú pro dedo. 2 minutos. Não goza.",
+  "🔥 ESCRITÓRIO SACO — Senta nu no PC, puxa o saco pra frente e massageia os ovos com uma mão enquanto a outra digita. 10 minutos trabalhando massageando o saco. De vez em quando passa o dedo do saco pra cabeça do pau. Sem gozar. Não goza.",
+  "🔥 QUINTAL MÃO LIVRE — Vai nu até o quintal, senta no chão e enfia o dedo no cú com uma mão. A outra mão livre fica apoiada no chão. Se alguém aparecer, a mão livre disfarça. 5 minutos de dedo no cú no quintal com a mão de alerta. Não goza.",
+  "🔥 PIA PROFUNDO — Nu na pia da cozinha, enfia o dedo médio no cú até o fundo. Sente a próstata com a ponta do dedo. Massageia com pressão firme enquanto a água lava os pratos. O pau começa a babar na água da louça. 4 minutos de pressão na próstata. Não goza.",
+  "🔥 JANELA QUARTO QUINTAL — Abre a janela do quarto que dá pro quintal, fica nu de quatro na cama virado pra janela e arregaca o cú. A janela aberta mostra teu cú pro quintal. Qualquer vizinho que olhar da casa deles vê teu cú na janela. 2 minutos. Não goza.",
+  "🔥 ESCRITÓRIO FINAL — Senta nu no PC, trabalha 30 minutos exposto. Durante esse tempo, enfia e tira o dedo do cú 10 vezes. Cada vez que enfia, conta até 20 antes de tirar. No final, fica 5 minutos com o dedo enfiado sem mexer. Não goza."
+]

ordens9.json

@@ -0,0 +1,113 @@
+[
+  "Imagine agora que você está na área de serviço aberta pro quintal, o vento tocando a pele pelada, e você finge que não viu seu vizinho na janela. Você abaixa a calça e a cueca sem pressa, se curva arreganhando a bunda e abrindo o cú pra ele ver, puxa o pau pra trás entre as coxas até a cabecinha aparecer por baixo do saco e ficar exposta, enfia dois dedos melados de saliva no cú em camadas, sente o anelzinho abrir pra dentro, e começa a fazer edging só na cabeça do pau, a glande latejando roxa entre os dedos, o pré-gozo escorrendo pelo vão das coxas, e você geme baixinho de boca aberta sabendo que ele tá te olhando da janela. Você aguenta o edging o quanto o corpo aguenta, mas quando vê a mão dele sumir da janela e o corredor do prédio escurecer, o tesão te domina de vez e você goza duro de pé na área de serviço, a porra quente espirrando no cimento frio, e fica ofegante olhando pra janela de novo, ainda acesa, esperando, sabendo que amanhã os dois vão resolver isso sem o vidro no meio.",
+  "Imagine agora que é madrugada e você acordou com o pau duro latejando, o pré-gozo manchando a cueca de tesão. Você vai pelado até a cozinha, abre a geladeira pra pegar agua gelada, e quando a luz ascende você vê o vizinho do prédio em frente imóvel na varanda dele, te encarando através do vidro. Você não se cobre: encosta na bancada, abre as pernas, pega no teu pau molhado e começa uma punheta lenta, passando o dedo no pré-gozo e levando à boca, provando teu próprio leite na frente dele, contraindo o cú a cada punhetada curta só na cabecinha. Ele também desabotoa a calça na varanda dele, e os dois se masturbam se encarando pela noite; ele goza primeiro, a mão fechada na luz do apartamento, e você continua te olhando até jorrar no copo de agua que ia ser tua bebida, a porra escorrendo pelo vidro gelado, e os dois se encaram num silêncio pesado, cada um lambendo a própria mão antes de desligar as luzes — mas nenhum dos dois fecha a cortina.",
+  "Imagine agora que você está de quatro no chão do quarto, pelado, procurando uma meia embaixo da cama quando a campainha toca. Você abre a porta esquecendo que tá nu e dá de cara com o entregador com o pacote na mão. Ele abaixa os olhos, vê tua rola dura balançando, e não desvia. Ele sorri, entra, fecha a porta e manda você se ajoelhar. Você ajoelha sem pensar, ele segura teu queixo, aponta o pau dele e diz que a assinatura da entrega é na tua boca. Você abre a boca larga, estica a língua e recebe o pau dele fundo, inchando a tua garganta, e ele segura tua cabeça e fode tua cara até gozar na tua língua. Você engole tudo, abre a boca vazia pra conferência, e ele ajeita a calça, pega o pacote do chão e entrega na tua mão como se nada tivesse acontecido. Quando você assina o recibo com a mão tremendo, ele diz que amanhã tem outra entrega e que dessa vez o pacote pode precisar de conferência dentro do quarto — e ele sai assobiando, te deixando de joelhos na entrada, com o gozo dele ainda no fundo da garganta.",
+  "Imagine agora que você está no churrasco da firma e a patroa loira te chama pra buscar cerveja no estoque. Ela tranca a porta, te empurra contra a caixa de bebidas, agarra teu pau por cima da calça e sussurra no teu ouvido que sempre sonhou em ver aquele corpo no escritório dela. Ela manda você ajoelhar e abrir a boca, e você chupa ela até ela gozar na tua boca gemendo baixinho entre as prateleiras. Depois ela te levanta, vira você de costas, desce a tua calça e a cueca, passa a mão melada no teu cú, mete dois dedos secos mesmo doendo, e ordena que você bata uma punheta pra ela até gozar numa sacola de lixo do estoque. Você goza de pé no quartinho escuro, a porra jorrando na sacola, e ela se masturba junto contigo vendo tua rola esvaziar. Ela ajeita a blusa, destrava a porta e volta pro churrasco como se o estoque só tivesse cerveja, mas no fim do dia ela te chama de lado e diz que segunda-feira às 18h você vai ter uma reunião particular no escritório dela — e que dessa vez é pra ir preparado.",
+  "Imagine agora que você está na cozinha amassando pão, pelado, as mãos enfiadas na massa quente quando a vizinha de vestido curto para na calçada, se pendura na janela baixa e te vê inteiro. Ela não vai embora: se encosta na parede, cruza os braços e levanta a barra do vestido pra esfregar a mão na própria buceta olhando você. Você entende o desafio, tira as mãos da massa, leva a mão farinhenta e suada pro pau duro e começa a bater uma punheta relaxada pra ela, devagar, mostrando a cabecinha, virando de lado pra exibir a bunda arreganhada também. Quando ela levanta o vestido e mostra a buceta molhada acesa na luz da tarde, o teu corpo enlouquece e você se derrama, gozando na bancada, a porra escorrendo pela mesa quente. Ela aplaude de longe, aponta pro próprio peito e entra em casa. Dez minutos depois ela tá na tua porta com a roupa ainda cheirando a farinha, pedindo uma fatia do teu pão — e o convite pra terminarem dentro da tua cozinha o que o vidro da janela já tinha começado.",
+  "Imagine agora que você está no vestiário da academia depois do treino, só de sunga, quando o personal trainer entra e tranca a porta. Ele não fala nada, só aponta pro chão. Você entende, tira a sunga, e fica de quatro na frente dele, a bunda no ar, o cú arreganhado de vergonha e tesão. Ele se ajoelha atrás de ti, enfia um dedo babado no teu cú, depois dois, massageando a próstata até tuas pernas tremerem, e com a outra mão segura teus quadris mandando você se esfregar no dedo dele como uma cadela. Ele manda você se virar e bater uma punheta olhando pra ele, fazendo edging até quase gozar e parar, 5 vezes, teu pau pulsando sem alívio, a glande roxa. Na quinta vez, quando tuas pernas já não seguram, ele se ajoelha na tua frente, limpa tua glande com a própria língua e diz que passou. Ele te dá um tapinha na bunda, pega a mochila e sai, mas antes de fechar a porta fala que amanhã no mesmo horário ele traz o plug pro aquecimento — e que o teu primeiro gozo no vestiário tá reservado pra ele.",
+  "Imagine agora que você está na maca do consultório, as pernas posicionadas, e a médica morena de luvas anuncia o exame de próstata. Ela enfia o dedo enluvado devagar contornando o anel, e quando a ponta curva encontra tua próstata, tua espinha arrepia e o pau endurece pingando. Ela não para: massageia o ponto em círculos lentos com o dedo dentro e envolve tua glande com a mão esquerda, girando o dedo indicador na cabecinha molhada, no ritmo do dedo do cu. Você geme, se abre, empurra o quadril contra as duas mãos dela, e ela manda você gozar assim, sem nem encostar no corpo, só no dedo pulsando dentro e a pressão na cabeça. Você obedece, esguichando na barriga, e ela não tira o dedo da próstata até o último espasmo, depois lambe a luva limpando o gozo na tua frente. Ela anota o resultado no prontuário e manda buscar a recepção pra marcar o retorno — e no papelzinho do exame, além do controle da próstata, ela escreve um horário fora do expediente e um apelido: vem sem cueca na próxima consulta, o exame precisa de mais calma.",
+  "Imagine agora que você está de bruços pelado na cama do hotel, a porta aberta, quando a camareira entra e te vê inteiro, a bunda arreganhada na direção dela. Ela não sai: entra, tranca a porta, e diz que a limpeza inclui reposição de toalhas e de outras coisas. Ela se ajoelha na cama atrás de ti, enfia um dedo no teu cú que você abre pra ela, depois dois, e fica massageando tua próstata até você gemer com a cara afundada no travesseiro. Ela manda você virar, pega teu pau duro na mão e chupa até tua perna tremer, faz edging 3 vezes te deixando no limite, e na quarta manda você jorrar na cara e nos seios dela como calibração do serviço. Ela sai do quarto com tuas toalhas sujas e o teu gozo secando na cara dela, fechando a porta com um sorriso que promete a volta. Meia hora depois ela volta com as toalhas limpas, pega teu pau ainda mole na mão e diz que a diária inclui a limpeza completa — e que a camareira do quarto ao lado também quer conferir se o serviço dela foi bem feito.",
+  "Imagine agora que você está na beira da estrada trocando o pneu, e um caminhoneiro para e desce te ajudando. Ele se agacha no teu lado pra olhar o pneu, e quando você alcança a ferramenta a tua camisa sobe e ele vê o pau duro escapando pela cueca. Ele ri, se levanta, desabotoa a calça dele e aponta: sua rolinha quer documentação. Ele manda você ajoelhar no asfalto quente, puxa tua cabeça e te guia até o pau grosso dele, e você suga fundo com os olhos vidrados nele enquanto os caminhões passam longe. Ele segura tua nuca e goza na tua boca, manda abrir a boca mostrando a porra e engolir, e depois ainda te obriga a terminar de trocar o pneu de joelhos, o gozo dele escorrendo pela tua garganta. Você enche a calibragem do pneu suado e de joelhos, e ele, no alto da cabine, grita pela janela que o próximo posto da estrada tem uma parada reservada e que te avisa quando a rota dele passar de novo por aqui. A poeira do caminhão cobre teu rosto enquanto você se levanta — e, no fundo, você sabe que vai pegar carona da próxima vez.",
+  "Imagine agora que é noite de lua cheia e você tá pelado na praia deserta, a água gelada na cintura, quando um casal maduro aparece caminhando pela areia. A mulher te olha de cima a baixo e diz pro marido que te quer. O marido concorda, e ela tira o vestido na areia, manda você deitar, senta com a buceta na tua boca fazendo você lamber até ela gozar, enquanto o marido se ajoelha atrás de ti e te come o cu com a mulher ainda sentada na tua cara. Eles trocam de posição: ele te faz deitar de frente, espalha tuas pernas e entra no teu cu de novo enquanto a mulher se abaixa e chupa teu pau molhado. Os três gozam juntos na areia, a porra escorrendo até a espuma do mar, e o casal se ajoelha nos teus lados e lambe o que sobrou no teu peito, cada um numa metade tua. Antes de irem, ela deixa o vestido na tua mão como lembrança e sussurra que toda noite de lua cheia eles voltam praquela praia — e que o convite vale pro próximo ciclo.",
+  "Imagine agora que você está no escritório depois do expediente, calça caída, numa punheta de tédio na frente do monitor, quando a colega entra sem bater e trava. Ela tranca a porta, sobe na cadeira giratória e se ajoelha na tua frente, puxa teu pau duro da tua mão e continua da onde você parou, chupando devagar com os olhos nos teus, parando quando você chega no limite. Ela te faz edging 4 vezes sentada nos calcanhares, e na quinta sobe na tua cara com o vestido aberto, mandando você lamber a buceta dela até ela gozar na tua língua. Depois ela desce e te chupa até você derramar na boca dela, engolindo tudo, e volta pra mesa dela como se nada tivesse acontecido, com o gosto dos dois na boca. Dez minutos depois o teu celular acende com uma mensagem sem nome: o número dela e o horário da reunião das 19h de amanhã, no andar vazio, porta fechada — e a última frase manda você ir sem cueca, porque o scan pessoal dela vai ser bem mais demorado.",
+  "Imagine agora que você volta pelado do banho e a síndica tá no teu corredor consertando o interfone. Ela te vê nu, não se apavora: entra, tranca, abre o caderno e diz que precisa vistoriar tudo com detalhes. Ela usa luvas de látex, manda você apoiar as mãos na parede, e vai checando a instalação: passa a luva no teu peito, na tua barriga, desce pela tua bunda e enfia o dedo enluvado no teu cú, abrindo pra inspeção, enquanto a outra mão segura teu pau e conta os batimentos como se fosse o pulso. Ela te vira e ordena que você bata uma punheta pra câmera noturna do celular dela, fazendo edging no comando dela, e só deixa gozar quando ela disser, com ela gravando tua cara contorcendo até a porra sair no chão do teu próprio corredor. Ela desliga a gravação, guarda o celular e diz que a vistoria tá aprovada, mas que uma unidade tão bem cuidada exige revisão mensal — e que na próxima ela traz o aparelho de medição maior. Ela sai destravando o interfone, e você fica no corredor com a porra ainda quente no piso, entendendo que o aluguel daquele apartamento passou a ser pago de outro jeito.",
+  "Imagine agora que você tá na piscina do condomínio às duas da manhã, pelado, flutuando, quando a vizinha do quinto andar desce pra fumar. Ela vê teu corpo e, em vez de ir embora, entra na água pelada também, se aproxima pelas costas, agarra teu pau pela água e te puxa pra superfície, te encostando no azulejo da borda. Ela chupa teu pau com a água batendo na tua pele, as mãos segurando teu saco, e depois te vira, te encosta de bruços na quina da piscina e esfrega a buceta dela na tua bunda, enfiando devagar até o fundo, gemendo abafado. Quando ela chega perto de gozar, ela te ordena virar e gozar com ela, e os dois esguicham na água escura, o cheiro de cloro misturado com o dos dois. Ela fica te segurando pela borda até o corpo parar de tremer, depois beija tua boca molhada e diz que a piscina daqui pra frente tem regra nova: banho noturno só com ela. Ela volta pro quinto andar com a camisola encharcada, e você fica boiando no escuro sabendo que vai passar a ter insônia de propósito toda madrugada.",
+  "Imagine agora que você tá numa trilha no mato, pelado, quando um homem alto aparece e sem dizer nada aponta pro toco de árvore caído. Você senta, abre as pernas, e ele se ajoelha entre elas, deita você de lado na madeira, passa saliva na tua bunda e entra no teu cu devagar, sem pressa, deixando você sentir cada centímetro abrindo teu corpo. Ele mete com o corpo curvado sobre o teu, a mão fechada no teu pau doído, e manda você se masturbar no ritmo dele, até vocês dois gozarem juntos — a porra dele lá dentro e a tua espirrando no mato. Ele se levanta, limpa as mãos na folhagem e segue a trilha sem dizer uma palavra, te deixando deitado pulsando na madeira, com o cú ainda cheio e as pernas bambas. Quando você se recupera e volta pro ponto de partida da trilha, encontra um bilhete preso num galho, escrito a mão, sem nome e sem assinatura: um horário e uma coordenada, e embaixo, uma única frase — no mesmo toco, da próxima vez você já vem de cueca abaixada.",
+  "Imagine agora que sua esposa dorme de bruços ao teu lado e você acordou com o pau duro. Você pensa que ela dorme e começa a punheta escondida embaixo do lençol, olhando a bunda dela arreganhada pra tua direção, o cú entreaberto. Você chega perto do gozo quando ela vira o rosto devagar, abre os olhos e sussurra que tá te sentindo há dez minutos, que não vai te ajudar, que quer assistir você se esvaziar sozinho como um menino escondido. Ela pede que você venha por cima dela, deite em cima da bunda dela, esfregue o pau nela e goze na pele; você obedece, com ela virada te olhando fixo, assistindo tua cara de sofrimento até a porra escorrer no meio das costas dela. Ela pede pra você lamber, e quando a tua língua toca a pele quente ela geme um gemidinho fingido de sono que você sente na espinha. Ela adormece de verdade de bruços, e você deita colado nela, lambendo devagar, sabendo que a manhã vai começar com aquela mesma cara de sono virada pra ti, cobrando o café — e a continuação.",
+  "Imagine agora que a amiga ruiva da tua esposa tá no quarto de hóspedes e a porta ficou entreaberta. Você passa pelado no corredor e vê o olho dela brilhando na fresta acompanhando teu peito, teu pau duro. Você não se cobre: para no meio do corredor, encara a fresta, pega no pau e começa a bater punheta devagar, mostrando pra ela. A porta abre mais, e ela tá de joelhos na cama se masturbando te olhando, o vestido levantado até a cintura, a mão enfiada na calcinha. Vocês dois se masturbam se encarando pelos olhos no escuro do corredor, um indo mais longe que o outro; quando o teu gozo sobe, ela abre a boca de olhos fechados te mandando gozar pra ela, e você derrama na frente da porta, exausto e sem pudor, enquanto ela se termina socando o próprio quadril na mão e geme alto sem conseguir conter. Ela abre a porta de vez, o vestido descendo, a boca molhada, uma mancha de tesão no tecido da calcinha, e te encara: diz que a tua esposa nunca vai saber de nada, mas que da próxima vez a porta vai ficar aberta de verdade — e que o teu nome vai sair da boca dela de um jeito que o travesseiro não vai esconder.",
+  "Imagine agora que você convidou um casal de amigos pro jantar e o assunto esquenta até ela te desafiar a provar teu corpo. Você se vê de joelhos no meio da sala, e eles mandam você rastejar até o tapete. O marido manda você se deitar de costas pra frente deles, ela se abaixa e chupa teu pau enquanto o marido se ajoelha na tua cabeça e manda você chupar o pau dele de ponta a ponta, os dois se movimentando em você como se você fosse um brinquedo de dois furos. Depois eles trocam: ele come teu cu com a mulher chupando tua rola de novo, até os dois gozarem em ti quase ao mesmo tempo — a porra dele no teu cu e a dela na tua boca. Você fica no chão melado, lambendo os restos do tapete escuro, servindo os dois de sobremesa, e eles se arrumam como se o jantar tivesse sido perfeito. Na despedida, a mulher te beija na boca na frente do marido, que sorri, e avisa que toda festa boa acaba com sobremesa — e que o próximo jantar é semana que vem, na casa deles, com o cardápio que você já sabe qual vai ser.",
+  "Imagine agora que uma mulher dominadora te ordena: calcinha de renda, camisola aberta nas costas e plug grosso no cu. Ela faz você deitar de bruços na cama com a calcinha afastada, puxa o plug com a mão e mete de novo devagar, deixando você gemer contra o colchão, e com a outra mão alcança teu pau por baixo e aperta a cabecinha até quase gozar, parando, fazendo edging até o limite 5 vezes com o plug enterrado. No final, ela manda você ajoelhar no chão, de costas pra ela, e bater uma punheta de quatro, com a calcinha fio dental no meio da bunda e o plug pulsando, até ela permitir o gozo — e ela filma tua cara se contorcendo com o próprio pau na mão. Ela termina a gravação no exato momento em que tuas pernas cedem e o gozo espirra pela renda da calcinha, e te deixa ajoelhado no chão por mais cinco minutos tremendo. Ela pega o celular, te mostra a própria cara contorcida e diz que o vídeo vai pro grupo das amigas dela só se você implorar — e você implora, de joelhos, e ela sorri, e grava a tua imploração também, ordenando que amanhã tem rodízio de plug da sala até o quarto.",
+  "Imagine agora que você está amarrado na cama, pulsos e tornozelos presos nas colunas com gravatas, e a mulher de vestido preto senta na tua cara sem pedir licença, com a buceta quente pressionando tua boca. Ela goza duas vezes na tua língua, segurando teu cabelo, e depois se ajoelha entre tuas pernas amarradas, com uma cinta roxa de 20 centímetros na mão. Ela lubrifica, alinha na tua bunda esticada e entra devagar apesar dos teus gemidos, te fodendo firme enquanto teu pau bate no ar sem alívio, e com a mão livre ela puxa teu pau e te masturba no ritmo das estocadas, até você implorar pra gozar. Ela só deixa quando tua voz falha, fazendo você esguichar amarrado com a cinta ainda funda no teu cú, o corpo todo tremendo em espasmos. Ela não tira a cinta: fica em cima de ti sentindo cada pulso até o teu pau secar, depois te solta devagar, massageia teus pulsos e diz que amanhã as gravatas vão ser trocadas por corrente de verdade. No corredor, antes de sair, ela para e avisa que você vai precisar do descanso — porque aquela primeira cinta foi só o aquecimento.",
+  "Imagine agora que você ficou invisível por um dia e entrou no vestiário feminino da piscina. Uma mulher de cabelo longo, pele lisa ainda molhada, entra, pendura a toalha e se despe devagar na tua frente, a blusa subindo, a calcinha descendo pelas coxas até ela ficar nua de frente pro espelho. Ela se senta no banco, abre as pernas pra se secar entre as dobras, e você fica parado vendo cada detalhe molhado, o pau invisível pulsando na mão invisível. Você se masturba na frente dela escondido, a um palmo da pele dela, cheirando o cheiro do sabonete misturado com o corpo dela, e goza silencioso no ar, a porra invisível caindo no piso frio. Ela termina de se secar, veste a calcinha e sai sem notar nada, mas esquece a toalha no banco. Você fica invisível no meio do vestiário, o peito subindo e descendo, e a noite inteira você dorme pensando no cheiro — até descobrir que o feitiço da invisibilidade não tem desfazer: ele só passa quando ela decide que você pode aparecer, e na manhã seguinte ela volta pra buscar a toalha, e dessa vez você vai estar visível, de joelhos, esperando.",
+  "Imagine agora que você tá sentado pelado num banco de praça de madrugada, pau duro, quando uma moça do bar senta do teu lado. Ela percebe teu volume, sorri, desliza a mão até tua calça e tira tua rola pra fora, apertando devagar na mão dela, e com a outra mão abre a própria calcinha na tua frente, puxando tua mão pra dentro. Vocês dois se entregam ali, ela se masturba na tua mão enquanto te masturba, trepando sentados no banco de praça, até ela pedir que você goze nas mãos dela. Quando você jorra, ela leva as duas mãos meladas à boca, lambendo cada gota na tua frente, e te beija passando o gosto na tua língua. Ela se levanta, ajeita o vestido como se nada tivesse acontecido, e antes de sair põe o número dela no teu celular com o apelido a madrugada — e some na direção do ponto de ônibus. A praça fica em silêncio de novo, e você fica sentado com o pau pulsando, sabendo que amanhã vai esperar ela no mesmo banco, e que ela sabe disso também.",
+  "Imagine agora que você tá na cadeira da barbearia, e quando o barbeiro termina de alinhar tua barba ele percebe tua ereção sob a capa. Ele tranca a porta, puxa a cortina e manda você tirar a calça: higiene de navalha exige área limpa. Ele reclina a cadeira, se ajoelha e chupa teu pau com uma técnica lenta de quem faz barba, parando nos beiços, usando a língua larga na cabecinha, fazendo edging até você implorar. Ele então sobe na cadeira, se posiciona de frente pra ti com o pau duro dele na tua boca, e você chupa ele em coro com ele te chupando, os dois se masturbando no ritmo um do outro, até gozarem juntos quase ao mesmo tempo. Ele limpa os dois gozos com a toalha quente de barbearia, te ajeita a gola da camisa e destranca a porta com um até a próxima raiz. No espelho, tua barba tá alinhada, mas tua cara ainda pulsa de vergonha e tesão — e no cartão do ponto de barbearia, em cima do preço, ele rabiscou um horário de madrugada e a palavra fechado pra você.",
+  "Imagine agora que você tá deitado na cadeira do dentista, e a dentista senta por acidente em cima de ti, sentindo tua rola dura sob o jaleco. Ela não levanta: se ajusta, sussurra que anestesia não é necessária, e desce o zíper da tua calça com as mãos enluvadas, puxando teu pau pra fora enquanto a broca do outro lado ronca parada. Ela te chupa devagar com a cadeira quase deitada, parando pra perguntar se tá doendo, e depois se levanta, joga a saia pro lado e senta na tua rola com a buceta quente, cavalgando em cima de ti até o trilho da cadeira começar a deslizar. Ela goza em cima de ti e te faz gozar dentro, e então sai da cadeira, se recompõe e entrega a receita com uma risquinha no rodapé: o telefone dela e um horário de retorno. Na porta da clínica ela apertaria tua mão um pouco além do normal e diz que da próxima vez o exame é no consultório particular, de porta fechada — e que o dentista que vem no horário dela sabe disso.",
+  "Imagine agora que você tá na fila do mercado de shorts, e uma mulher gostosa encosta em ti de propósito, rebolando o rabo na tua rola dura por cima do tecido. Você fica duro feito pedra enquanto ela finge não perceber a pressão encostando a cada movimento da fila. Ela vira o rosto, pisca, e aponta com o queixo pro corredor de produtos de limpeza, o mais vazio. Você segue ela, e no fundo do corredor ela te puxa pra dentro do depósito, tranca, se ajoelha e chupa teu pau com fome, com as mãos apertando teu saco, e depois te vira de costas, encosta você na pilha de papel higiênico e come teu cu ali mesmo, gemendo abafado, até te fazer gozar no chão frio do depósito. Ela se recompõe, puxa a blusa e volta pro caixa com o sorriso impecável, a tua porra ainda secando na coxa. Teu estoque inteiro passa no caixa dela, e no troco, junto das moedas, ela enfia um papelzinho com o número dela e um horário de madrugada — conferência de estoque.",
+  "Imagine agora que você tá na sessão vazia do cinema e uma moça de cabelo curto senta do teu lado, coloca a cabeça no teu ombro e desliza a mão até tua calça, pegando no teu pau duro por cima do tecido. Ela te masturba ali mesmo, com o som do filme cobrindo teus suspiros, e quando percebe que o gozo tá subindo ela sussurra que precisa ir ao banheiro. Ela te leva pelo corredor escuro, te puxa pra dentro da cabine acessível, tranca e se ajoelha, chupando teu pau até a garganta com a mão apertando o teu saco, e depois se vira, arregaça o short e manda você comer ela de pé contra a porta da cabine, a película tremidora do filme passando luminosa sob a porta enquanto os dois gozam juntos no banheiro. Ela limpa com papel, puxa o short e sai como se fosse só mais uma visita ao banheiro, e vocês assistem o final do filme de mãos dadas no escuro. Na saída do cinema ela te espera no estacionamento com a chave do carro na mão, beija tua boca e diz que a sessão das 20h de amanhã já tá reservada — mas que o filme ela quer assistir do banco de trás.",
+  "Imagine agora que a tua dona te põe de castigo de joelhos no quarto, ainda de meias, e manda você arregar o cú na direção do espelho. Ela senta na poltrona e manda você bater uma punheta lenta de costas pra ela, olhando teu reflexo: quero ver a tua cara de puta. Você se masturba devagar enquanto ela critica o ritmo e manda você enfiar um dedo no cu junto, empurrando pra dentro, a glande roxa refletida no espelho. Você chega perto do gozo 4 vezes e ela estala os dedos te fazendo parar no limite, o pau pulsando sem remédio, e no final ela diz que hoje você não vai gozar de jeito nenhum. Ela manda você lavar o dedo e guardar o tesão pra amanhã, e te deixa de joelhos tremendo na frente do espelho, o gozo preso latejando dentro de ti. Ela só sai do quarto quando você abaixa a cabeça, e no corredor ela deixa o celular gravando tua imagem encolhida no espelho; pela madrugada, chega a mensagem dela: uma foto tua de joelhos e o texto — amanhã você vai me mandar um vídeo se agradecendo por eu ter segurado você.",
+  "Imagine agora que você é o modelo nu da aula de desenho, em pé no pedestal no meio dos cavaletes, e o professor manda você abrir mais as pernas. No fundo da sala tem uma aluna que não desenha, só te encara. Quando a aula acaba ela fica, espera a sala esvaziar, sobe no pedestal e diz que precisa estudar os detalhes de perto. Ela se ajoelha na tua frente, puxa teu pau duro e chupa devagar na luz da janela, com a mão no teu quadril, e depois manda você deitar no chão do estúdio, senta com a bunda nua na tua cara pra você lamber até ela gozar. No fim, ela te faz gozar por cima do desenho dela, marcando o papel com as manchas da tua porra. Ela levanta o papel, assina o canto com um sorriso e diz que aquela obra de arte ela vai emoldurar — e que o modelo de amanhã, no mesmo horário, é obrigatório. Na porta, ela apaga a luz e completa: e dessa vez eu quero você se virando sozinho quando eu entrar.",
+  "Imagine agora que você tá nu na sala de espelhos do estúdio de ioga, e a instrutora alta manda você se ajoelhar na postura da criança e empinar o quadril. Ela se aproxima por trás, senta na tua bunda com a buceta por cima do teu cú, manda você arregar pra sentar melhor — e monta em ti com a virilha colada na tua pele. Você sente o calor da buceta dela esfregando na base da tua rola enquanto ela instrui tua respiração, cada movimento te deixando mais doído, e depois ela desce, pega teu pau e, numa posição de alongamento, te chupa entre as próprias pernas, se contorcendo até os dois gozarem em uníssono no espelho, sem quebrar a postura nenhum momento. Quando o gozo passa, ela mantém a posição por mais um minuto, respira fundo e te beija. Ela desliga a luva de luz da sala e diz que a aula de amanhã é sobre alongamento — e que você deve vir sem roupa, porque o tecido prende a energia. O espelho devolve a imagem dos dois suados e parados, e você já tá agendando mentalmente a próxima respiração profunda.",
+  "Imagine agora que você tá de bruços na maca da massagem, e a massagista, depois das costas, manda você virar. A toalha escorrega, tua rola fica na vertical, e ela nem pisca: unta as mãos com óleo quente e começa a trabalhar a região pélvica — desliza pela tua virilha, envolve tua glande com a palma e vai massageando em círculos com a base do polegar, subindo devagar até você se esticar todo. Ela pega o vibrador que tava na bandeja, passa óleo, enfia no teu cú e liga na intensidade micro, enquanto a mão enrola teu pau; ela monta teu lombo, te fazendo gozar sem tirar o vibrador, o jato espirrando no teu próprio peito. Ela desliga o vibrador depois do último espasmo, te entrega a toalha limpa e agenda a próxima sessão pra amanhã no mesmo horário, anotando no caderno: livre, fosso, vibrador, controle. Você sai com as pernas bambas e o cheiro de óleo na pele, e a agenda dela da semana inteira já tem o teu nome em todas as linhas — você só não sabe disso ainda.",
+  "Imagine agora que você tá sozinho acampando, pelado na barraca, quando uma moça das trilhas aparece pra esquentar as mãos na tua fogueira. Ela percebe o teu tesão, sorri e pergunta se pode se aquecer melhor. Ela entra na barraca, se despe na tua frente, monta sobre tua cara com a buceta quente pingando e manda você lamber até ela gozar, e depois vira o jogo: senta no teu colo de costas, puxa teu pau pra trás entre as coxas dela e se esfrega nele enquanto guia tua mão pra enfiar um dedo no teu próprio cú. Quando o gozo dos dois chega junto, ela manda você jorrar pra fora da barraca, na terra, como oferenda ao fogo, e te beija com o gosto dela ainda na tua boca. Ela limpa a boca, se veste, dá um beijo na tua testa e some na trilha antes do Sol nascer, deixando o cheiro dela estampado na barraca. Quando você arruma a mochila, encontra um papelzinho dobrado com um mapa da trilha e um X marcado — aqui é onde a gente se encontra no próximo camping, escrito no meio do desenho do Sol.",
+  "Imagine agora que você é arte viva numa galeria erótica, em pé numa moldura de veludo vermelho, e uma senhora elegante de tailleur espera todo mundo sair da sala. Ela cruza a corda, sobe no pedestal e tira as luvas devagar, uma a uma. Ela toca tua rola dura, sente o calor pulsante, pede que você ajoelhe na plataforma e desce a calcinha dela pra você lamber a buceta madura ali, no silêncio da galeria. Ela goza em pé na tua boca, se recompõe e depois pega a bandeja de vidro que servia de adorno, manda você se masturbar até gozar em cima dela como se fosse arte contemporânea e leva a bandeja com a tua porra pro fundo do corredor, dizendo que vai pendurar aquilo na parede reservada da casa dela. Na semana seguinte você recebe um convite de vernissage em casa alheia — e no meio da sala de jantar, na parede reservada, tá a bandeja emoldurada com as tuas manchas, com uma plaquinha de ouro: obra doada por admiradora. Quando a senhora te encontra no centro da sala, ela ergue a taça na tua direção e brinda, em silêncio, arrumando outro encontro pra aquela semana.",
+  "Imagine agora que você vive num reino imaginário e a rainha manda despir na corte inteira. Nu sob o teto abobadado, ela desce do trono, toca teu peito com o cetro, manda você rastejar atrás dela através do salão até os aposentos. Lá dentro ela te amarra pelas mãos na cama real, senta com a buceta na tua boca, e depois de gozar chama duas criadas e manda que brinquem com teu corpo: uma chupa tua rola enquanto outra enfia um vibrador de quartzo no teu cu, a rainha assistindo da cadeira, e manda parar quando tuas pernas tremem. Depois ela se ajoelha entre tuas coxas amarradas, segura tua glande molhada e te faz gozar na bandeja de ouro, provando com a colher de prata como quem saboreia um manjar real. Ela aprova com um aceno e os criados te carregam pra um banho de mármore; e naquela noite, quando ela manda te chamarem de novo, você entende que o teu destino no reino é ser provado todas as noites — até a colher se acostumar com o teu sabor — e que você já não sabe mais se quer ser provado por mais ninguém.",
+  "Imagine agora que você tá no banho e percebe uma câmera espiã acesa no canto do box. Você entende que tá sendo filmado nu desde sempre, e em vez de te proteger, o tesão grita mais alto: você se vira pra lente, ensaboa o pau e começa uma punheta lenta, abrindo as pernas, enfiando um dedo no cú com o sabão escorrendo, se exibindo pra quem quer que esteja do outro lado. Você imagina os olhos atrás da lente se esfregando enquanto assistem tua glande latejando na câmera, e goza direto pra lente, a porra escorrendo pelo azulejo do box. Depois limpa a boca com a língua e manda um beijo pra câmera, desafiando teu espião a aparecer pra fazer a continuação ao vivo — e a câmera pisca duas vezes, como resposta. No dia seguinte tem um envelope na tua caixa de correio, sem carimbo, com um bilhete: te vi de perto, segunda-feira, 21h, portão dos fundos. Você guarda o bilhete e, na segunda-feira às 21h, você tá lá — e entende que a câmera espiã nunca foi pra te vigiar: era pra te chamar.",
+  "Imagine agora que a moça de dreads do caixa do mercado segura tua mão ao devolver o troco e sussurra que te segue até o depósito. Lá dentro, no chão frio entre as caixas de bebida, ela puxa tua rola pra fora com as duas mãos e chupa com os olhos subindo pra ti, parando no limite, e depois te ordena que você lamba a buceta dela até ela gozar no teu rosto suado. Ela se vira, arregaça a farda e manda você comer ela de pé encostado nas pilhas, com as latas balançando a cada estocada, até os dois gozarem no meio do estoque. Ela volta pro caixa com a tua porra escorrendo pela coxa, te cobra a compra com um sorriso e diz que a próxima conferência de estoque é amanhã no mesmo horário. No estacionamento ela te espera com o carro ligado, e do banco do passageiro ela te beija e completa que amanhã a conferência é na casa dela, porque o depósito do mercado tem câmera escondida — e que o rolê que ela quer fazer contigo não cabe em horário de expediente.",
+  "Imagine agora que você tá no ônibus lotado às sete da noite, e uma mulher de casaco sentada na janela te puxa pro colo. Por baixo do casaco estendido sobre vocês dois, ela desliza a mão quente até tua calça, abre o zíper devagar e puxa tua rola pra fora, masturbando teu pau no colo dela com os dedos contornando a glande em silêncio absoluto, os passageiros mexendo nos celulares. O balanço do ônibus acelera o tesão, e ela sente teu pau engrossar na mão até quase transbordar; então tira a própria calcinha pela cintura e te guia pra dentro dela ali mesmo, os dois gozando abafados naquele sussurro, o ônibus inteiro alheio. Ela desce no ponto dela com o corpo ainda tremendo e te devolve um papelzinho dobrado com o número e o horário do mesmo ônibus de amanhã. Você fica sentado com a calcinha dela enfiada no teu bolso — ela colocou sem avisar — e a viagem de volta inteira é só a tua mão escondida segurando o bilhete, contando as horas.",
+  "Imagine agora que você tá pelado na piscina da tua casa e a faxineira do vizinho sobe no muro pra recolher a mangueira, te vendo na água. Ela não desvia: manda você sair, e você obedece nu, a água escorrendo. Ela olha tua rola dura brilhando, desce do muro pelo portão e diz que o equipamento dela tá entupido, precisando de limpeza. Ela se ajoelha na beira da piscina, chupa teu pau com a mão fechada na base, com a água formigando na tua pele, te faz edging 3 vezes, e depois manda você sentar na borda pra lamber a buceta dela enquanto ela se termina; os dois gozam com o som da água e da mangueira. Ela volta pro quintal do vizinho com tua porra na panturrilha e um recado no portão: o material dela nunca mais entupiu com a tua ajuda. À tardinha, ela cruza o muro de novo, agora de short curto, dizendo que o equipamento dela entupiu de novo — só que dessa vez ela entra na piscina junto, e vocês terminam na água enquanto a casa do vizinho dorme do outro lado da cerca.",
+  "Imagine agora que você tá nu na sauna, o vapor espesso, e um homem maduro de anel de prata senta na tua frente. Ele nota tua rola endurecida com o calor, tira o anel e pede que você passe devagar na tua haste, como amuleto, assistindo a argola deslizar na cabecinha molhada. O vapor adensa a tensão, ele se aproxima, se ajoelha no banco de madeira e chupa teu pau com a língua quente, usando o anel como joia no teu anelzinho, e depois se vira, abre as pernas e pede que você faça o mesmo serviço nele, os dois se degustando no calor, até ele pedir que você goze no peito dele — e ele enxuga tua porra com a língua enquanto a sauna fecha. Os dois saem rubros e em silêncio, com o anel de volta no dedo dele, e no vestiário ele te dá um cartãozinho de horário da sauna de amanhã, às 20h, com o nome dele no verso. Quando a porta fecha, você percebe que, no meio do caminho, o anel que ele usava agora tá no teu dedo — e a promessa da sauna de amanhã pesa mais que a prata.",
+  "Imagine agora que você tá no elevador panorâmico com uma executiva de tailleur quando ele trava entre andares. Na penumbra ela te encara, desabotoa a tua calça sem pedir licença e puxa tua rola pra fora, masturbando devagar com a mão gelada de anéis. Ela manda que você se vire pro vidro, e com o peito colado nas tuas costas ela contorna teu pau em edging pela transparência da cidade lá embaixo, sussurrando que o resgate vai demorar horas e que ela prefere se esquentar. Ela se ajoelha atrás de ti, lambe teu cú e enfia um dedo firme, te masturbando olhando tua cara refletida no vidro, e ordena que você goze na janela panorâmica — a porra escorrendo pelo painel com a cidade acesa atrás. Ela limpa com o lenço da bolsa, aperta o botão de emergência e, quando o elevador volta a funcionar, descem juntos sem trocar mais uma palavra. No corredor do térreo, a mão dela aperta a tua ainda com o gozo secando nos dedos, e de madrugada teu celular acende com uma mensagem sem número: reunião às 21h no último andar — e o elevador vai quebrar de novo.",
+  "Imagine agora que você tá na cadeira do salão, e a cabeleireira de seios grandes percebe tua ereção sob a capa depois de encostar em ti de propósito. Ela tranca a porta da cabine privada, tira a capa te deixando só de cueca e manda você despir de vez. Ela reclina a cadeira, se senta na tua cara com a saia preta levantada e goza na tua língua duas vezes com a mão segurando a poltrona; depois pega tua rola e chupa com a boca quente de batom, te fazendo edging até a beira, quando pede que você goze por cima do peito aberto dela e limpa se lambendo o dedo. Ela te devolve arrumado, ajeita tuas mechas e cobra o corte na maquininha com uma piscadela, anotando teu número no celular. Quando você sai, o teu celular vibra com a mensagem: máscara de reconstrução capilar, terça, 19h — e o capilar foi só o começo.",
+  "Imagine agora que você tá no provador da loja de roupas, de cueca com o pau duro marcado, e a vendedora entra sem bater pra ajudar com a numeração. Ela se ajoelha pra medir a barra, mas a mão sobe por dentro da tua perna, encosta na tua rola e aperta com a palma quente. Ela te manda experimentar o modelo, tira a cueca de tuas camadas, e chupa teu pau de pé na cabine apertada, com as outras provadoras alheias do outro lado da cortina, você mordendo o lábio pra não gemer no meio da loja. Ela te vira, te encosta no espelho do provador e come teu cu de pé até os dois gozarem, com a tua cara em êxtase colada no espelho. No caixa ela te cobra a calça escandalosamente cara, dizendo que o desconto especial tá embutido no preço do prazer dela — e dentro do saco, junto com a roupa, um cartãozinho com o turno dela de sexta e a palavra provador circulada de batom. Na sexta, no mesmo horário, o provador da loja tá reservado em silêncio, e a cortina presa pelo lado de dentro.",
+  "Imagine agora que você tá nu numa banqueta de estúdio, sob o holofote, e a fotógrafa de cabelo azul te orienta poses eróticas de todas as formas: deitado, abrindo os joelhos, mão na virilha. Ela pede que você coloque a mão no pau, e quando você obedece ela diz: vai até o limite, sem gozar, eu filmo. Ela te faz edging na frente da lente, gravando tua cara sofrida em 4K, e depois se abaixa, coloca a câmera no tripé filmando o ângulo do chão, sobe na banqueta, monta em tuas costas com a calcinha aberta e se masturba na tua bunda enquanto manda você gozar pro chão na frente da lente, gravando cada gota caindo no asfalto frio do estúdio. Ela desliga a câmera no último pingo, baixa o tripé e te mostra o take final em câmera lenta, frame a frame, até a porra bater no chão. Ela salva o arquivo com o nome o gozo refletido e destranca a porta, dizendo que a exposição de abertura é sexta e que o teu lugar é na parede principal — mas que a obra definitiva ela quer filmar na casa dela, de porta fechada e sem espectador.",
+  "Imagine agora que você tá no banheiro do bar com um amigo do teu irmão, e na frente do mictório você percebe que tua rola não desce. Ele percebe, ri e te puxa pra cabine trancando a porta. Ele desabotoa a calça dele e mostra o pau duro de lado pra você, e sem pedir licença encosta o corpo, incentivando você a pegar no dele. Vocês dois se masturbam em pé na cabine, se olhando, cada um sentindo o cheiro quente do outro, e quando ele percebe que você tá no limite ele se ajoelha no chão do banheiro e chupa teu pau até te fazer gozar na boca dele, engolindo tudo com os olhos nos teus. Ele levanta, limpa a boca com as costas da mão e pergunta se você vai contar pro seu irmão o que aconteceu no mictório — com a tua boca ainda aberta, sem conseguir responder. Dez minutos depois ele volta pra mesa do bar como se nada tivesse acontecido e puxa assunto com teu irmão; mas por baixo do balcão, a mão dele encontra a tua e aperta, te avisando que o mictório de sábado tá reservado — e você descobre que não vai conseguir mais beber cerveja nesse bar sem ficar duro.",
+  "Imagine agora que você tá numa balada e uma mulher de coturno te puxa pelo cabelo pro banheiro do andar de cima. Ela tranca, te joga de joelhos, tira o cinto e bate na tua bunda nua até marcar, te chama de putinha, manda você abrir a boca e chupar os dedos embebidos em gel. Ela enfia um plug pequeno no teu cú, e quando ele tá enterrado ela te levanta, te vira de frente pro espelho sujo e manda que você se masturbe pra tua própria cara: quero ver essa cara de piranha até caber. Ela faz edging com você no espelho, parando no limite 4 vezes, e na quinta manda gozar na pia do banheiro, filmando tudo com o celular cunhado na mão, dizendo que aquela gravação vai de story privado pra quem ela quiser. Ela te ajuda a limpar, puxa tua calça e te guia pra fora com o pulso ainda na nuca; na porta da balada ela segura teu queixo: sexta, 23h, mesma balada, eu te procuro. Você volta pra mesa com o rosto queimando e a bunda marcada, e passa o resto da noite com o celular na mão, contando os dias pra sexta.",
+  "Imagine agora que você é o garçom de um restaurante fino, e uma cliente de vestido vermelho te chama na mesa reservada pra provar o vinho. Ela levanta a barra do vestido quando você se abaixa, e você vê que ela tá sem calcinha, a buceta madura na altura da tua cara. Ela segura tua cabeça, te puxa pra debaixo da toalha e manda você lamber até ela gozar enquanto o salão inteiro janta em volta; ela goza na tua língua abafando o gemido com a toalha, te tira de lá e te manda reto pro banheiro. Quando você volta, ela tá com a tua calça no colo: ela tirou tua calça por baixo da mesa enquanto você lambia, e ela te chupa no vão escuro sob a toalha até a tua porra jorrar na taça de vinho. Ela ergue a taça, cheira, brinda baixinho pra ti e bebe tudo de um gole, com os olhos cravados nos teus. No final da noite, na gorjeta do cartão de visitas, além do dinheiro, um papel pequeno com o nome de um hotel e um horário marcado — e a frase: a mesa de amanhã já tá reservada no teu nome.",
+  "Imagine agora que você descobre um cômodo secreto no subsolo do teu trabalho, e tua chefe de óculos tá lá dentro, de coleira no pescoço te esperando. Ela manda você se despir, se ajoelhar e entrega na tua mão o controle remoto do plug que ela mantinha no teu cú o dia todo; ela liga no máximo e te deixa vibrar até tuas pernas falharem, tua rola dura escorrendo no chão da sala secreta. Ela se senta na cadeira de veludo, abre o notebook e trabalha enquanto te vigia: manda você bater uma punheta devagar, parar quando ela levantar o dedo, gozar só quando ela mandar — e ela grava teu rostinho contorcendo por cima da mesa dela, te fazendo implorar, até ela acenar com a caneta e deixar você jorrar na sala. Ela fecha a pasta com teu nome e diz que a gravação ficou perfeita — mas que a versão que ela vai usar depende da tua próxima visita às terças, às 22h, sem falta. Ela te entrega a roupa na porta do elevador de serviço, e quando a porta fecha, o sistema de reconhecimento já registrou a tua próxima entrada na agenda.",
+  "Imagine agora que você tá no trem noturno, e acorda de madrugada com a mão de um homem de terno entre as tuas pernas, por dentro do pijama. Ele não para quando você acorda: pede desculpas num fio de voz e continua, masturbando teu pau duro devagar, o trem balançando nas curvas, teus joelhos apertando as coxas. Ele percebe tua respiração presa e faz um edging lento, chegando ao limite e parando, tirando a mão e deixando você pulsando na madrugada, repetindo 3 vezes enquanto a cabine fica mais quente; na quarta, ele se ajoelha no chão do beliche, puxa tua pijama inteiro pra baixo e chupa tua rola até a garganta, te fazendo gozar com a mão na boca pra não acordar o trem inteiro. Ele limpa a boca, deita no beliche de baixo e cochila como se nada tivesse acontecido, o cheiro dos dois ficando na cabine até de manhã. Quando você desce na estação, encontra no bolso da pijama um bilhete: comboio das 23h, cabine 7 — o bilhete de volta é teu. E no bolso do casaco do terno, esquecido na cabine, o telefone dele, sem calma pra apagar o número antes do bilhete.",
+  "Imagine agora que você tá no motel com uma conquista, e depois da primeira dose ela finge dormir de bruços, com o pé roçando tua coxa. Você entende o convite: ajoelha atrás dela, cheira a bunda arreganhada e começa a se masturbar por cima dela, o pau duro passando rente à pele, e sem querer ela vira o rosto, abre os olhos e sussurra: pode gozar? Você tá atônito, e ela te puxa pro colo dela, abre as pernas, monta em cima de ti e se esfrega na tua rola molhada, cavalgando até os dois jorrarem juntos, o corpo dos dois selado de suor. Depois ela puxa tua mão pra beijar os dedos e diz que no motel sempre tem segunda parte quando o parceiro sabe o começo — gargalhando de ver tua cara de quem ganhou na loteria. Ela fica deitada no teu peito e pede que você conte o começo de novo, que ela quer ouvir a história da tua voz, enquanto as mãos dela já deslizam pra cima do segundo round. Você percebe que o fingi dormir dela foi só o primeiro ato — e que a noite no motel ainda vai ter terceira, quarta e quinta parte.",
+  "Imagine agora que você é o brinquedo escolhido no harém, e a sultã manda você despir na frente das mulheres do séquito sentadas em tapetes. Nu no centro, elas te devoram com olhares, e a sultã manda você rastejar entre as pernas dela. Você vai lambendo as coxas, a buceta quente, e uma das mulheres atrás enfia um vibrador no teu cú enquanto você lambe, fazendo você gemer com a boca cheia. A sultã goza na tua língua, e depois o harém inteiro brinca com teu corpo: uma te chupa, outra enfia os dedos em ti, uma amarra tuas mãos atrás das costas — e no fim a sultã manda que você se masturbe de joelhos pro harém inteiro, contando cada gota que cai no prato de prata. As mulheres batem palmas delicadas quando o prato se enche e a sultã prova o teu gozo com a ponta dos dedos; depois te levam pro banho de mármore cantando baixinho. Deitado nas sedas, você entende que aquele tributo virou o vinho da rainha — e que o harém inteiro agora quer a tua colheita — e você percebe que já tá com vontade de servir a colheita de novo.",
+  "Imagine agora que você tá no quarto de hospital, soro na veia, e a enfermeira da noite entra pra medir tua pressão e te encontra com o pau duro marcando o lençol. Ela baixa o lençol, ri com carinho e diz que a fisioterapia da recuperação exige estímulo circulatório. Ela aciona a alavanca da cama, te deita de bruços e começa a massagem nas costas que escorrega pra bunda, e quando a mão alcança tua virilha ela vira teu quadril, te vira de costas, aponta o monitor cardíaco pra ti — e te masturba devagar olhando os batimentos acelerarem na tela, te fazendo chegar ao limite e parando, edging lento enquanto anota a frequência nas enfermarias da noite. Às 2h47 ela finalmente deixa o gozo sair, com o monitor disparando luzinha e os dois abafando risada com a mão na boca; ela limpa tuas coxas com o papel da cama, ajusta o soro e anota tua frequência no prontuário com um sorriso. Na porta ela para e avisa que amanhã tem mais, com troca de turno — e que a colega da manhã também vai querer conferir teu progresso. O monitor cardíaco ainda pisca alto no escuro, e você entende que a tua recuperação vai ser longa — e gostosa.",
+  "Imagine agora que um apocalipse passou, você é o último homem vivo, e encontra um grupo de mulheres numa praça abandonada. Elas te cercam, tocam teu corpo nu como bens preciosos, e a líder de cabelo grisalho anuncia o rodízio: cada noite uma de vocês te come, e você obedece. A primeira monta em ti na capota de um carro abandonado, cavalgando até gozar; a segunda te vira e te come o cu de pé no meio da praça, assistida pelas outras; a terceira se ajoelha e chupa teu pau até tuas pernas tremerem; e a quarta amarra as tuas mãos no poste e te faz gozar diante de todas, filmando na mão como um ritual de recomeço da humanidade. Você dorme exausto sob as estrelas, o corpo marcado de mordidas e porra, e acorda no dia seguinte com as mulheres cozinhando frutas e rindo, planejando a noite seguinte como quem sortearia quem fica com o teu leite. No fim do café, antes de o Sol subir de vez, a líder te puxa pela mão pra sombra da praça e diz que o rodízio noturno agora tem escala definida: todas as noites, na ordem que o conselho decidir — e que o teu papel no mundo recomeçado é agradecer de joelhos toda vez, até o dia em que elas escolherem você em silêncio.",
+  "Imagine agora que você tá de frente pro balcão de congelados do supermercado, escolhendo iogurte com uma calma que você não sente, quando uma mão quente e decidida desliza por dentro da tua calça por trás, abre a tua cueca no meio da bunda e encosta a ponta dos dedos direto no teu cú, arrepiado de susto e tesão. Você trava, segura a porta de vidro do balcão pra não cair, e a mão desconhecida começa a trabalhar os dedos: passa o indicador em volta do anelzinho, pressiona de leve e enfia um dedo inteiro pra dentro sem pressa, enquanto atrás de ti uma voz abafada sussurra pra você continuar escolhendo iogurte como se nada. Você tá duro feito pedra dentro da calça, os outros clientes passando alheios, e o dedo dentro do teu cú se mexe devagar, dobrando na próstata até tuas pernas falharem; a mão tira o dedo, fecha a tua cueca e a calça, e quando você vira só vê o vulto dela sumindo no corredor dos frios — mas no teu bolso de trás tem um papel dobrado com um horário e a palavra congelados. Você termina a compra com as pernas bambas e, às 22h, no estacionamento, ela tá te esperando no carro com a mão já dentro do próprio short.",
+  "Imagine agora que você tá na fila do caixa do mercado com as compras no chão, quando sente uma mão deslizar por dentro da tua calça por trás, abrir a tua cueca e pressionar a palma inteira na tua bunda nua, os dedos fechando sobre o teu cú com uma calma criminosa. Você fica imóvel, o coração acelerado, a pessoa atrás de ti fingindo falar ao celular, e os dedos começam a brincar: um passa babado pelo anel, dois se insinuam devagar pra dentro enquanto você morde o lábio e segura a barra do carrinho; o caixa te chama pra pagar e você dá um passo com o dedo ainda te abrindo, a voz falhando no débito. Quando a mão sai, ela aperta tua bunda uma última vez e sussurra no teu ouvido que o pacote que você deixou cair no corredor 8 não tinha nada, mas que ela viu você se abaixar pra pegar. Você paga com as mãos trêmulas e, na saída, no estacionamento, ela tá encostada no carro dela à tua espera, com a mão no bolso e um sorriso de quem sabe exatamente onde usou os dedos.",
+  "Imagine agora que você tá no hortifruti do mercado dando tapinhas numa melancia, sentindo o peso dela, quando atrás de ti uma mão firme entra por dentro da tua calça e da tua cueca de uma vez, segura tua bunda por inteiro e enfia dois dedos no teu cú sem nenhum aviso, fazendo você quase derrubar a melancia no chão. A dona da mão, uma mulher alta de chapéu, finge examinar as frutas do lado, e os dedos dela trabalham dentro de ti em sessões curtas: entram, dobram, massageiam teu ponto, saem quando alguém se aproxima e voltam com mais dois quando alivia. Você fica mole no fim do hortifruti, o tesão subindo até a nuca, obrigado a ficar parado com a mão enfiada na tua bunda no meio do mercado; ela termina, arranca uma etiqueta de preço da melancia, escreve um número com a unha e gruda atrás do teu celular. Quando você finalmente entende e vira, ela tá na fila do caixa te olhando por cima do ombro, apontando com o queixo pro corredor das frutas tropicais.",
+  "Imagine agora que você tá escolhendo carne na frente do balcão de vidro do açougue, quando por trás uma mão ágil entra pela tua calça, abre tua cueca e acha teu cú direto, como quem conhece o caminho. Os dedos começam a trabalhar sem cerimônia: o indicador desliza pelo anel, o médio entra e sai devagar, enquanto no balcão o açougueiro te pergunta o ponto do bife e você responde mal passado com a voz saindo esquisita. A pessoa atrás de ti ri baixinho, os dedos dobrando no teu cú enquanto o açougueiro embrulha a carne, e o atendente chama o número da senha no exato momento em que o dedo te abre mais fundo, fazendo teus joelhos travarem na hora de pagar. Ela tira a mão, ajeita tua calça e finge ler o celular, mas antes de sair puxa tua camisa por cima do cós e deixa um bilhete de papel de açougue no teu bolso: a hora do fechamento da ala e uma frase — trago a carne, você traz onde ela entrar.",
+  "Imagine agora que você tá na padaria do bairro esperando o pão francês esfriar na bandeja, quando uma mão pequena e quente entra por dentro da tua calça e cueca por trás, segura tua bunda e desliza os dedos na fenda do teu cú com uma calma de quem tem tempo. Você congela no meio da fila, e os dedos começam a trabalhar teu buraco: um enfia devagar, agarrando teu quadril pra te segurar, enquanto a dona da mão pede em voz alta duas dúzias de pão de sal do teu lado. O padeiro atrás do balcão te olha sem suspeitar, e o dedo dentro de ti dobra e massageia tua próstata até o teu pau escorrer dentro da cueca, e você precisa morder o lábio pra não gemer no meio da padaria. Ela tira o dedo no exato momento em que a sacola quente chega na tua mão e passa por ti com um bom apetite sorrateiro, deixando no fundo da sacola de pão um cartãozinho de papel manteiga com nome, telefone e a frase: os dedos da próxima fornada são teus pra guardar. Você volta pra casa com o pão quente na mão e o cú ainda aberto, sabendo que amanhã cedo vai pedir pão no mesmo balcão.",
+  "Imagine agora que você tá parado no corredor de vitaminas da farmácia lendo um rótulo que você não tá lendo, quando sente uma mão entrar por dentro da tua calça por trás, abrir tua cueca e achar teu cú num piscar de olhos. A dona dela, uma moça de jaleco do laboratório, finge revisar a prateleira ao teu lado, e os dedos começam a dançar no teu anel: o polegar espalha um gelzinho frio que devia ser de massagem, o indicador entra inteiro e alisa tua próstata enquanto ela sussurra que a farmácia tem câmera, sim, mas que o ângulo do corredor 3 não alcança os dois. Você se apoia na prateleira, duro, o jaleco roçando na tua lateral, e os dedos entram e saem no ritmo da conversa dela sobre dosagem de vitamina, até ela enfiar dois de uma vez e te deixar gemer baixinho abafado no papel do rótulo. Ela termina, passa um cartão de fidelidade no teu bolso com o telefone dela riscado e diz que a retirada é no caixa ao lado, horário das 21h — e que o desconto do medicamento ela desconta em pessoa, com as luvas.",
+  "Imagine agora que você tá subindo a escada rolante do shopping, seguindo na direção das lojas do segundo piso, quando a pessoa no degrau de trás, colada em ti, enfia a mão por dentro da tua calça e cueca e segura tua bunda sem nenhum aviso. A escada continua subindo, o movimento puxa os corpos, e os dedos da pessoa trabalham teu cú em silêncio: um entra devagar no ritmo do mecanismo da escada, outro se insinua e te abre mais, enquanto do lado a escada que desce leva dezenas de pessoas olhando na tua direção. Você fica imóvel, a mão no corrimão, o pau duro esmagado contra a calça, e a desconhecida atrás de ti respira quente na tua nuca e sussurra que o próximo degrau é dela, que ela não se vira. Ela te leva até o limite da escada, os dedos girando na tua próstata, e quando vocês chegam no topo ela solta, dá um beijo no teu pescoço e some no meio da multidão; mas o teu celular vibra com uma mensagem de número desconhecido: tô no terceiro piso, no banheiro do cinema, com a porta aberta e a mão molhada. Você fica na ponta da escada rolante escolhendo entre a loja e a porta — e o teu corpo já decidiu antes da tua cabeça.",
+  "Imagine agora que você tá num corredor de livros de uma livraria grande, procurando um romance na estante alta, quando um homem de terno encosta em ti por trás, pede licença e apoia a mão no teu ombro — mas a outra mão desliza por dentro da tua calça, abre tua cueca e encontra teu cú no escuro do corredor. Ele fala em voz baixa sobre os livros, os dedos trabalhando teu buraco: um entra inteiro, dobra, alisa, sai e volta com dois, enquanto você se equilibra na ponta dos pés fingindo ler as lombadas, o pau endurecendo contra a estante. O corredor tá vazio, mas qualquer passo pode cruzar, e os dedos dele aproveitam cada segundo, te abrindo no ritmo da voz enquanto ele cita autores; quando o teu joelho enfraquece, ele te segura pela cintura e enfia três dedos fundo, te deixando gemer dentro de um livro grande aberto na tua mão. Ele tira a mão, ajeita a tua calça num gesto seco e vira o corredor sem olhar pra trás; no teu bolso, um marcador de página com um horário e a frase: a sessão de autógrafos é no estoque, às 22h, e o convidado especial é teu cú.",
+  "Imagine agora que você tá na fila do banco, número na mão, esperando a senha ser chamada, quando a mulher atrás de ti encosta o corpo no teu e enfia a mão por dentro da tua calça por trás, cuidando de abrir a cueca e achar teu cú sem tirar o sorriso de fachada. Os dedos dela trabalham teu buraco com discrição total: um dedo entrando e saindo no ritmo da música ambiente, dobrando na próstata sempre que o sistema chama uma senha, fazendo você segurar as costas da cadeira com as juntas brancas. O guarda do banco passeia o olhar por vocês dois e nada vê, enquanto os dedos dela te levam três vezes até a beira do gozo e três vezes te trazem de volta, só de dedos, no meio da fila. Quando o teu número finalmente é chamado, ela dá um tapa seco na tua bunda, fecha tua cueca e sussurra que o saque de hoje é dela — e que o extrato tá no teu bolso de trás. Você anda até o caixa com as pernas bambas, saca, sai, e no estacionamento ela tá escorada num carro, empurrando o próprio short pro lado e apontando pros bancos de trás.",
+  "Imagine agora que você tá espremido no metrô lotado às 18h, de mão na bala de cima, quando sente uma mão entrar por dentro da tua calça por trás, por baixo da mochila, abrir tua cueca e ganhar teu cú no aperto da multidão. O movimento do trem joga os corpos, e os dedos da pessoa atrás trabalham teu buraco: um entrando e saindo no ritmo das estações anunciadas, enquanto a mulher colada em ti finge segurar o próprio celular e sussurra o nome da próxima estação como quem avisa a parada. Você tá duro no meio de dezenas de pessoas, a mão dela avançando dentro de ti em cada freada do metrô, dobrando a próstata quando o túnel fica escuro e soltando quando a luz volta, no ritmo perfeito do balanço. Quando a estação final dela chega, ela se desgruda, ajeita tua cueca rapidinho e desce sem olhar pra trás; a mão dela deixa um bilhete de papel amassado no fundo do teu bolso: mesma plataforma, mesmo horário, amanhã — traz a cueca de futebol, que eu quero ver o time entrando em campo.",
+  "Imagine agora que você tá na catraca do ônibus lotado, apertado na saída, e atrás de ti um homem de terno desliza a mão por dentro da tua calça, abre tua cueca pela fenda e toca teu cú com a palma inteira, os dedos fechando sobre o anel sem pressa. O ônibus sacoleja, as pessoas penduradas, e os dedos dele entram devagar, um, depois dois, trabalhando teu buraco enquanto ele finge conferir o troco do cobrador e pergunta em voz alta que ponto é aquele. Você tá duro e vermelho, segurando a barra, o rosto virado pra janela, e o dedo dele dobrando por dentro te faz morder a boca de todas as formas pra não gemer no meio da balbúrdia; ele enfia três quando o ônibus curva, te deixa a um fio do gozo e segura firme. Quando a porta da frente abre no ponto do centro, ele desliza a mão pra fora, fecha tua cueca e te empurra leve pra descer: seu ponto, né. Na calçada, o teu celular vibra com uma mensagem de número oculto — eu saí no mesmo ponto que você; tô na tua cola até o próximo ônibus, e dessa vez o banco de trás vai tá quase vazio.",
+  "Imagine agora que você tá na fila da pipoca do cinema, batendo o pé de impaciência, quando pela multidão do lobby uma mão entra por dentro da tua calça e cueca por trás e segura tua bunda com firmeza, os dedos encontrando teu cú e começando a brincar nele com uma calma de quem vai tirar o filme de um lugar vazio. Você congela na fila, o balde de pipoca na mão, e os dedos trabalham teu anel com o barulho do cinema abafando tudo: um entra inteiro e dobra, a ponta alisando tua próstata enquanto os adolescentes da bilheteria riem de alguma coisa no canto. A mão atrás de ti te segura num ritmo que acompanha os trailers: para quando a luz apaga, volta quando a sala escurece de vez; e quando o longa começa, ela enfia dois fundos e te leva ali mesmo, na fila escura, até tuas pernas travarem sem ninguém notar. Ela tira a mão, ajeita tua calça e te dá o troco da pipoca junto com uma nota de cinema amassada com um horário e o número da sala 6 — e na sala 6, na poltrona do fundo, ela já tá sentada com a mão no próprio colo, esperando você ocupar o lugar do lado.",
+  "Imagine agora que você tá na feira livre de sábado olhando as barracas de verdura, quando entre a multidão alguém chega por trás e enfia a mão por dentro da tua calça por baixo do boné abaixado, abre tua cueca e toca teu cú com os dedos quentes de segurar sacola. O movimento da feira empurra todo mundo, os pedestres passando amontoados, e os dedos trabalham teu buraco em silêncio: entram, viram, dobram, e cada vez que uma feirante grita o preço da laranja, o dedo te dá um soco fundo na próstata, fazendo teus olhos lacrimejarem de tesão contido. Você segura uma abobrinha sem conseguir soltar, e a pessoa atrás de ti, uma mulher de lenço na cabeça, comenta com a feirante o preço do tomate enquanto os dedos dela descrevem círculos dentro de ti. Quando ela termina, ajeita tua roupa num gesto de quem só esbarrou, e coloca na tua sacola de feira um embrulho de pano com uma banana dentro e um bilhete com um horário e o nome do bar do final da feira; no bar, às 13h, ela te espera na mesa dos fundos com a mão na própria calça, dizendo que a banana é só o aperitivo.",
+  "Imagine agora que você tá na fila da casa lotérica na segunda de manhã, segurando o volante de aposta, quando atrás de ti uma mulher de casaco encosta o peito nas tuas costas e a mão dela entra por dentro da tua calça, abre a cueca e pressiona a palma inteira no teu cú, os dedos fechando o anel com uma força que não pede permissão. A lotérica tá cheia de gente conferindo bilhete, e ela trabalha teu buraco com os dedos: um entra de lado, dois entram de frente, dobram na tua próstata no momento exato em que a tela da lotérica grita teu número da sorte. Você se encosta no vidro do balcão, duro, segurando o jogo com a mão tremendo, e ela continua enfiando e tirando os dedos no ritmo dos números que passam na tela, te levando três vezes até a beira de um gozo público. Quando é a tua vez de apostar, ela te dá um tapinha na bunda, ajeita tua cueca e sussurra que o prêmio de hoje não é da lotérica, é do carro estacionado do lado do mercado. Você aposta no escuro, sai com o bilhete no bolso e o cú pulsando — e ela tá lá, no carro, com o cinto desabotoado.",
+  "Imagine agora que você tá na fila do buffet de um restaurante self-service na hora do almoço, bandeja na mão, escolhendo arroz e feijão, quando a mão de uma colega de trabalho que tá atrás de ti na fila desliza por dentro da tua calça por trás, abre tua cueca e acha teu cú no meio da pressa de todo mundo se servindo. Você trava com a colher de arroz no ar, e ela, sorrindo pra tua reação, enfia o dedo devagar no teu anel enquanto continua conversando sobre o relatório da tarde, como se a mão dela não estivesse dentro da tua cueca no meio do restaurante. A fila anda, ela te segue, os dedos entrando e saindo do teu cú no ritmo das conchas de salada, dobrando na tua próstata quando você alcança a carne; o salão lotado em volta, ninguém vendo, só os dois sabendo que o almoço dela tá te comendo de pires. Ela termina no balcão de sobremesa, ajeita tua calça num gesto rápido e pega um pudim, dizendo que depois do almoço tem reunião na sala dela — e que o relatório que ela quer ver é o teu, de perto, com a porta trancada e o pudim sendo provado nos teus joelhos.",
+  "Imagine agora que você tá sentado no banco do terminal de ônibus aguardando a linha da noite, quando a mulher do casaco comprido, que também espera, senta do teu lado e enfia a mão por dentro da tua calça por baixo da coberta fina que ela esticou sobre os dois, abrindo tua cueca e ganhando teu cú com os dedos numa discrição de teatro. O terminal tá lotado, gente correndo pro ônibus, e ela trabalha teu anel em silêncio: dedo entrando, dedo dobrando, o polegar apertando o períneo, enquanto pergunta em voz alta que horas o próximo ônibus passa, como se a mão não estivesse enfiada em ti. Cada anúncio de chegada no alto-falante te dá um soco de adrenalina, e ela usa o sobressalto pra enfiar mais fundo, dobrando na próstata até tuas pernas se abrirem no banco; quando o ônibus dela finalmente chega, ela dá um último toque, tira a mão, ajeita tua cueca e desce pra linha dela sem olhar pra trás. Você fica sentado no terminal com o pau latejando, e quando o teu próprio ônibus chega, no banco de trás, tem um bilhete encostado no vidro escrito à mão: a linha da meia-noite, próximo sábado — e dessa vez o banco vai ser o de trás, vazio, com as cortinas fechadas.",
+  "Imagine agora que você tá no meio da multidão de um show de rock, pulando com todo mundo, suado, quando no aperto do público uma mão estranha consegue entrar por dentro da tua calça por baixo da camisa amarrada, abrir tua cueca e agarrar tua bunda, os dedos ganhando teu cú no pulso da música. O som tá alto, todo mundo pulando, e os dedos trabalham teu buraco no ritmo da bateria: um dedo entrando em cada refrão, dois dobrando na ponte, e toda vez que a galera grita no solo da guitarra, a mão te abre mais fundo, te deixando duro feito pedra no meio do mosh. Você segura a mão de quem tá do lado, que nem percebe, e a mão invisível atrás de ti continua te comendo de dedos, te levando perto do gozo e te segurando no limite durante três músicas inteiras. No fim do show, quando o estádio liga as luzes, a mão solta, ajeita tua cueca e a pessoa some na multidão que desce as escadas; no teu bolso de trás, um canhoto de ingresso amassado com um vestígio de batom rosa e a frase por cima do desenho do palco: o próximo show tem camarote — eu desço o dedo com você assistindo da grade.",
+  "Imagine agora que você tá na academia no meio de uma série de agachamento na barra, quando uma instrutora se aproxima por trás pra corrigir tua postura e, aproveitando que o aparelho abraça os dois, desliza a mão por dentro da tua bermuda, abre tua cueca e prende os dedos no teu cú, testando tua forma por dentro. Ela fala em tom de treino sobre o alinhamento do quadril enquanto os dedos entram e saem, o suor escorrendo pela tua nuca, a academia cheia de gente se olhando nos espelhos sem enxergar nada além de um treino de postura. Cada agachamento que você faz enterra os dedos dela mais fundo, dobrando na tua próstata até tuas pernas tremerem de verdade no meio da série; ela para quando você chega na última repetição, te mantém no limite e te segura firme, sussurrando pra você finalizar o agachamento sem gozar. Na saída, ela te chama no canto, escreve no teu caderno de treino um número de telefone e a palavra quarto: sexta, 19h, treino de descanso ativo — e o aquecimento você já conhece.",
+  "Imagine agora que você tá na fila dos Correios no fim do expediente, com uma encomenda registrada na mão, quando o homem do terno cinza atrás de ti enfia a mão por dentro da tua calça por trás, sem tirar o olhar do celular, abre tua cueca pela fresta e sente o anel do teu cú com a ponta dos dedos, como quem confere uma etiqueta. O atendente chama as senhas e a fila anda devagar, e os dedos dele trabalham teu buraco na cadência do guichê: um dedo entra inteiro quando ele atualiza a tela, dois entram quando você dá um passo pra frente, dobrando na próstata e te fazendo segurar o pacote com as duas mãos pra se equilibrar. A fila dos Correios tá cheia de aposentados e estudantes, ninguém olhando pra trás, e ele te leva duas vezes até o fio do gozo enquanto o sistema anuncia próximo, guichê 4; quando é a tua vez, ele finalmente tira a mão, ajeita tua cueca e te cutuca pra andar: seu guichê. Você despacha a encomenda com a voz engasgada, e na saída teu celular acende com um número não salvo: encomenda registrada recebida com sucesso — retirada no endereço que eu anotei no vidro do teu carro, hoje às 22h, pelo portão dos fundos.",
+  "Imagine agora que você tá sentado num banco do parque no fim da tarde, tomando um sorvete de casquinha, quando a moça de vestido floral senta na ponta do banco e, aos poucos, por baixo da mochila que ela apoia entre vocês, a mão dela desliza por dentro da tua calça, abre tua cueca e chega no teu cú com os dedos gelados de segurar o copo. O parque tá cheio de gente passando, cachorro atravessando a grama, e ela trabalha teu anel com uma calma de domingo: um dedo entrando e saindo devagar, dobrando na tua próstata quando um casal de velhos passa bem devagar na tua frente, de mãos dadas. Você fica sentado com o sorvete derretendo, duro, os olhos presos no horizonte, e os dedos dela te levam três vezes até o pé do gozo, cada vez segurando e recomeçando, sem pressa nenhuma. Quando o Sol baixa e o parque esvazia, ela tira a mão, ajeita tua cueca, empresta o guardanapo pra tua mão melada de sorvete e diz que o banco é bom, mas que a cama da casa dela é melhor; ela anota o número no guardanapo e some pela trilha, e o teu sorvete derretido esquenta menos que o cú arrepiado.",
+  "Imagine agora que você tá no quarto com a janela aberta de cima a baixo, a luz acesa, pelado, com o plug de metal enfiado no cú e a cabeça do pau já aparecendo pelo elástico da cueca que você puxou pro lado. Você se vira de costas pra janela, se curva e pega nas duas nalgas, abrindo o cú com as mãos até o plug de metal brilhar no meio da bunda, e rebola devagar pro escuro da rua, imaginando o vizinho do prédio de trás com os olhos pregados naquele cú escancarado. Você mantém a posição com o plug pulsando, arregando o anel mais ainda, deixando a glande molhada aparecer entre as coxas a cada rebolada. Quando a janela do vizinho se acende e você vê a silhueta de mãos na cintura, o tesão vence e você enfia um dedo ao lado do plug, socando dentro de ti pelado na frente da janela, até a porra espirrar pelo chão do quarto com o plug ainda enterrado, e você fica de quatro no tapete, ofegante, sabendo que amanhã vai deixar a luz acesa de novo.",
+  "Imagine agora que você tá na área de serviço com a porta escancarada pro quintal no fim da tarde, só de camiseta apertada, a bunda pelada empinada na direção da casa ao lado, arreganhando o cú com as duas mãos como quem mostra mercadoria. Você abaixa devagar, curva mais fundo, e enfia o dedo indicador no cú, mexendo dentro do buraco exposto pro ar livre, o pré-gozo escorrendo pela coxa enquanto a cabeça do pau roxa pinga por baixo. A vizinha passa na varanda dela, freia, e fica te olhando de cima a baixo sem disfarçar; você não fecha a porta: dobra mais, abre, enfia dois dedos, e rebola a bunda arreganhada mostrando tudo pra ela, até ela balançar a cabeça com um sorriso e descer a escadaria dela. A noite cai e ela vem até o teu muro baixo, se aproxima por trás, e com um toque na tua bunda manda você continuar — os dedos voltam a trabalhar teu cú exposto, agora com o olhar dela de perto, você goza de quatro na grama do quintal, a porra cortando o ar, enquanto ela observa cada gota sem tirar os olhos da tua bunda aberta.",
+  "Imagine agora que você tá no quintal ao entardecer, de costas pro muro, calça e cueca nos tornozelos, e você inclina o corpo pra frente arreganhando a bunda contra a parede de tijolos, o cú escancarado com o plug grosso enterrado e a base dele pulsando na fresta. Você abre as pernas, puxa o plug com um dedo e enfia de volta devagar, exibindo o movimento pro vizinho que tá regando as plantas do outro lado e já parou de regar pra olhar o teu show. Você roda de lado e puxa o elástico da cueca descida pra mostrar a cabecinha melada, esfregando a glande com a ponta do dedo na frente dele, de pé no quintal, sem nenhuma vergonha. Ele cruza os braços no muro, assiste você se masturbar de cabeça pro muro mostrando o apertar do cú no plug a cada movimento; quando você goza, a porra escorre pela parede de tijolos, e ele manda um aceno seco e volta pra mangueira — mas no dia seguinte, pendurado no galho da tua árvore, tá um bilhete amarrado com barbante marcando o mesmo horário.",
+  "Imagine agora que você tá na cozinha de frente pra janela baixa que dá na rua, cozinhando pelado da cintura pra baixo, a bunda nua empinada enquanto mexe a panela, arregando o cú de propósito a cada movimento pro vidro. Você pega o plug de silicone que deixou na bancada, se curva mais pra janela e enfia devagar no cú, gemendo baixinho com o ar da rua frio no anel aberto, e depois se agacha pra pegar a farinha, mostrando a glande da rola dura pendendo entre as coxas por baixo. O carteiro passa na calçada, trava pra olhar, e você continua cozinhando de bunda pro vidro, rebolando com o plug enterrado como se fosse a coisa mais natural do mundo. Ele some pra entregar as cartas, mas vinte minutos depois toca a tua campainha pra um 'recalculo de entrega', e quando você abre a porta de frente ainda com o plug dentro, ele te empurra pra cozinha, te dobra sobre o fogão e te arromba o cú ali mesmo, com a panela fervendo do lado e a janela aberta pro mundo ver.",
+  "Imagine agora que você tá na garagem com a porta inteira rebatida de pé, meio-dia, pelado em cima de um colchonete velho, de quatro, com o cú exposto direto pro portão aberto da rua. Você mantém a posição por muito tempo, arregando o anel com as mãos, enfiando o dedo com calma e mostrando o movimento molhado pra quem passar; um motoboy reduz na frente da garagem, alguns pedestres desviam e voltam pra olhar, e você continua ali, exibido, o plug pequeno na mão esperando a vez de entrar. O tesão sobe de ter tanta gente vendo, você enfia o plug, arregala o cú pra calçada e ainda puxa o pau pra trás entre as coxas pra mostrar a glande brilhando do lado de baixo. Você se masturba de quatro na garagem aberta, a porra jorrando no colchonete no meio da tarde ensolarada, e quando levanta, um vizinho da frente tá parado na própria calçada, cruzando os braços: você sorri, dá tchau com a mão suja, e ele volta a andar — mas de noite ele te chama pelo muro, querendo ver de perto o que ficou no colchonete.",
+  "Imagine agora que você tá no elevador do teu prédio de madrugada, vazio, e decide que ninguém vai subir até teu andar: você baixa a calça e a cueca, vira de costas pra câmera de segurança do elevador e arregala a bunda com as duas mãos, mostrando o cú inteiro pra lente, depois pinga saliva e fica arregando e fechando o anel pro registro. Você se agacha de cócoras de frente pra câmera, o pau pendendo, e puxa a cabeça do pau pra cima mostrando a glande melada na luz fria do elevador, se masturbando ali, parado, enquanto o elevador sobe andar por andar. Quando a porta abre no teu andar, você veste num piscar e sai; no dia seguinte, o porteiro do turno da manhã te entrega um envelope discreto com a tua cara na tela da câmera congelada — e um bilhete pedindo pra você repetir o espetáculo às 3h, no subsolo, onde ele cuida da manutenção sozinho.",
+  "Imagine agora que você tá na laje do prédio de madrugada, com a cidade inteira acesa lá embaixo, pelado com o plug de metal enterrado no cú e a cabeça do pau exposta no vento, se exibindo pra vista de ninguém e de todos ao mesmo tempo. Você se curva na beirada da laje, arregando o cú com o plug brilhando na luz da cidade, enfia o dedo ao lado dele, junta saliva e soca devagar no anel já aberto, mantendo a posição pro alto, como quem oferece o cú pro céu. Você senta num tijolo na borda, abre as pernas, puxa a glande pela ponta e vai levando até quase gozar, parando, depois recomeça, com a brisa gelada na pele e o plug pulsando. Quando a porra finalmente jorra, espirra na laje e some na noite, e você fica de quatro arregando o cú uma última vez pro vazio da cidade; embaixo, na sacada do vigésimo andar, alguém tá te vendo há meia hora — e no dia seguinte, na portaria, tem uma caixa sem remetente com um bilhete e um laço de presente.",
+  "Imagine agora que você tá na varanda da frente do apartamento, a grade baixa, com a porta da sala aberta e a luz acesa, pelado de quatro encostado na grade, arregando o cú na direção da rua e do prédio da frente. Você enfia o dedo no próprio cú exposto no meio da grade, movendo devagar, mostrando o buraco pra quem olha da calçada, e de vez em quando vira de lado, abaixa o corpo e expõe a glande da rola pendendo entre as aberturas da grade. Dois andares de frente, numa sacada, um casal tá com latinhas na mão te assistindo sem esconder; você continua o show, enfia dois dedos, arregala o anel pro casal e se masturba de quatro na varanda até gozar no piso frio, a porra escorrendo entre as grades. O casal bate palmas de longe, e meia hora depois o interfone toca: é a moça do casal, do outro lado, dizendo que desceram pra beber uma cerveja com o artista da varanda e que querem conferir de perto o que a fechadura faz com o plug.",
+  "Imagine agora que você tá dentro do carro estacionado num beco escuro às 23h, os vidros embaçados, as calças abaixadas, e você abre a porta do carro de propósito, virando de costas pro vão da porta e arreganhando a bunda e o cú com plug pra escuridão da rua deserta. Você mantém o carro meio aceso pra quem passa enxergar o contorno, enfia o dedo no próprio cú ao lado do plug exposto ao ar livre da calçada, mexendo devagar e arregando o anel pra direção do poste de luz. A cabeça do pau aparece entre as tuas coxas quando você se vira de lado no banco, e você puxa a glande melada, mostrando por alguns segundos pela janela aberta do carro, com o coração batendo de ser visto. Quando um casal de idosos atravessa a rua na tua frente e desvia o olhar, você goza ali mesmo, dentro do carro de porta aberta, a porra jorrando pelo capacho do passageiro, e depois fecha a porta devagar, liga o carro e vai embora — sem saber que o guarda noturno do quarteirão anotou tua placa, e que na noite seguinte ele te espera no mesmo beco, de prancheta na mão.",
+  "Imagine agora que você tá no vestiário de uma piscina pública, com a porta travada por uma mochila pra ficar entreaberta, pelado de frente pro espelho grande, arregando a bunda com o plug de metal e enfiando o dedo no cú exposto, mantendo a posição de costas pra fresta da porta. Você se curva no banco, abre o anel com os dedos na frente do espelho, mostrando o interior do cú pra quem passasse no corredor, e depois roda, puxa o elástico da calça imaginária e expõe a glande molhada no vidro, se masturbando de pé no meio do vestiário. Passos se aproximam por fora, mas a porta segue meio aberta e você não fecha: um homem entra pra trocar a roupa, te vê pelado exibindo o cú arreganhado, para e fica olhando sem falar. Você vira pra ele, mantém o dedo no cú, e ele larga a sacola, se aproxima, se ajoelha atrás de ti e começa a trabalhar o plug de dentro com a mão; você goza de pé no vestiário, a porra escorrendo pelo espelho, e ele sai depois sem se identificar — mas a molhada dele ficou no thy sacola, junto do número do apartamento dele escrito na etiqueta.",
+  "Imagine agora que você tá no estacionamento vazio do mercado à noite, entre dois carros, calça e cueca desabotoadas, encostado no vidro traseiro de um carro, arregando a bunda e o cú com as mãos na direção do corredor de acessos. Você curva com as palmas no vidro, enfia o dedo no próprio cú exposto sob as luzes do poste, movendo devagar pro carro do lado, com o vão entre as vagas aceso e à vista de quem passar. Roda de lado, puxa a glande melada pra fora da cueca baixa e esfrega a ponta do polegar nela, se masturbando de pé no meio do estacionamento, com a brisa noturna batendo na bunda arreganhada. Um carro entra no estacionamento, reduz, dá a ré pro lado de vocês e fica com o farol baixo iluminando teu cú aberto; você não desvia: mantém o dedo dentro, arregando pra luz, até gozar escorrendo pelo vidro do carro alheio — e o motorista, uma mulher de óculos escuros, abaixa o vidro e pergunta se tu sabe onde fica a vaga preferencial, porque ela prefere estacionar do teu lado toda noite.",
+  "Imagine agora que você tá no banheiro da piscina do condomínio, com a porta destravada e meio encostada, agachado de cócoras pelado, arreganhando a bunda e o cú na fresta, enfiando o dedo com calma no buraco exposto pro corredor dos vestiários. Você se levanta, vira de lado pro espelho, e puxa a cabeça do pau pela base, mostrando a glande veiada com gota de pré-gozo, se masturbando ali de pé na penumbra do banheiro público. Outra pessoa entra pra usar o banheiro, dá de cara com teu show na fresta, e em vez de sair, trava e fica olhando; você não fecha a porta, abaixa o corpo, arregala mais o cú e continua, com as orelhas quentes de tesão e vergonha misturados. Quando a pessoa sai e a porta trava, você goza de cócoras no chão do banheiro, a porra escorrendo pelo ralo, e se limpa com a toalha do pescoço; ao voltar pro torno da piscina, encontra um recado na sua cadeira, papel de guardanapo com um número e a frase: a porta trancada é a única diferença de hoje pra amanhã.",
+  "Imagine agora que você tá na academia depois do horário, quase vazia, pelado da cintura pra baixo na frente do espelho grande da sala de treino, de costas, arregando a bunda e o cú com as duas mãos e enfiando um dedo na sua frente do teu reflexo, se exibindo pro vidro e pra câmera do canto. Você se curva na barra, abre o anel com o dedo, molha os lábios com saliva e trava, mantendo o cú escancarado na direção do espelho e da porta de vidro da recepção, a glande pendendo entre as coxas à mostra. Você levanta, puxa a cabecinha pra fora da calça descida e se masturba em pé na frente do espelho, com o plug no chão te esperando; enfia o plug, rebola arregando o cú no vidro, e goza de frente pra tua própria imagem, a porra espirrando no espelho da academia. No dia seguinte, o personal-chefe te chama na sala dele e devolve tua foto congelada pela câmera em cima da mesa, com um sorriso: o horário de manutenção da câmera é toda quarta às 22h, e o tapete do salão fica livre — se você tiver a coragem de repetir.",
+  "Imagine agora que você tá numa duna de praia deserta ao pôr do sol, pelado, deitado de bruços na areia quente, arregando a bunda e o cú com as mãos pro céu aberto, o plug de metal brilhando no meio do anel à luz dourada. Você se apoia nos cotovelos, levanta o quadril e enfia o dedo no próprio cú exposto pro horizonte, mexendo devagar e arregando o buraco com a ponta, a brisa salgada batendo no interior exposto. Deita de costas, abre as pernas, e puxa a glande melada pra fora, deixando a cabeça do pau exposta ao vento do mar enquanto se masturba pro pôr do sol, sem ninguém por perto além das gaivotas. No auge do gozo, a porra espirra na areia ardente e some imediatamente, e você fica de bruços arregando o cú uma última vez pro sol morrer, exausto e liberto; quando levanta e veste, descobre pegadas frescas adiantando no areal, vindas do lado oposto — alguém assistiu tudo, sentado ao longe, e deixou um desenho no chão: um círculo com um ponto no meio e a flecha apontando pra tua direção.",
+  "Imagine agora que você tá numa trilha deserta no meio do mato, pelado, parado no cruzamento dos dois caminhos com a mochila na mão, arregando a bunda e o cú com as duas mãos em pé, mostrando o buraco aberto pro ar da mata pro caso de alguém surgir na curva. Você caminha devagar pelo atalho, curva em cada clareira, e a cada parada abaixa a parte de trás do corpo, abre o cú com os dedos e enfia um dedo melado de saliva no interior exposto, brincando até a glande melada aparecer por baixo entre as pernas. O mato esconde metade do teu show, mas quem passa pela trilha principal enxerga a bunda arreganhada e o movimento do dedo na fenda; você se agacha, enfia o plug que tinha no bolso da mochila, arregala o anel pro caminho e se masturba de quatro na terra, a glande roçando no capim. A porra jorra na folhagem seca, e quando você se limpa, um casal de mochileiros aparece na curva com os olhos arregalados — eles passam sem dizer nada, mas no comedor da clareira seguinte deixam pendurado pra ti um bilhete com o nome da pousada deles e o quarto reservado pro 'artista da trilha', se ele quiser expor de perto.",
+  "Imagine agora que você tá no banheiro do restaurante com a porta quase trancada, meio encostada, e decide deixar aprovada uma fresta: pelado da cintura pra baixo, de quatro no piso frio, arreganhando a bunda e o cú na direção da porta, com o plug médio enterrado e a glande da rola pendendo entre as coxas. Você puxa o plug devagar, mostrando o anel aberto, e enfia de volta, arregando mais, o barulho das mesas e dos pratos chegando pela fresta enquanto você trabalha o próprio cú exposto ao corredor do salão. Um garçom abre a porta pra checar, te vê naquela posição de quatro exibindo o plug, e em vez de fechar, fica parado na fresta assistindo você gemer baixinho arregando o cú pra ele. Você goza assim, de quatro no banheiro do restaurante, a porra pingando no ladrilho, e ele tranca a porta por fora com o charminho da chave antes de voltar ao salão; meia hora depois ele te serve a sobremesa com um recado no guardanapo: o banheiro de funcionários, no fundo do corredor, fica aberto até — e a porta tem trinco dos dois lados.",
+  "Imagine agora que você tá na varanda do hotel no décimo segundo andar, madrugada, pelado com a porta do quarto aberta e a luz ligada, de quatro encostado na grade, arregando a bunda e o cú com o plug de metal refletido na janela do prédio do outro lado. Você enfia o dedo ao lado do plug, movendo devagar o interior exposto pro quarto do edifício vizinho, que tá com a cortina aberta esperando o show começar; depois vira de frente, apoia as costas na grade, abre as pernas e mostra a glande melada, se masturbando em pé na varanda iluminada. No quarto vizinho, uma mulher parada na janela acompanha teu ritmo com a mão se movendo na própria calcinha; você rebola de quatro, arregala o cú na direção do vidro dela e goza com a porra espirrando pela grade do doze andar, caindo na rua lá embaixo. A janela dela se fecha devagar, mas vinte minutos depois, pela fresta da tua porta, desliza um papel: o número do quarto dela, no mesmo andar, com a frase — a próxima de quatro é na minha sacada, e o plug eu trouxe.",
+  "Imagine agora que você tá atrás do posto de gasolina de madrugada, no vão escuro entre o compressor de ar e a parede do caixa, pelado da cintura pra baixo, de costas pro movimento da rua, arregando a bunda e o cú com as mãos enquanto enfia o dedo no próprio buraco exposto ao asfalto. Um frentista sai pra recolher a mangueira, te vê naquele vão exibindo o cú escancarado com o dedo entrando e saindo, e fica imóvel com a mangueira na mão, assistindo você se expor sem pressa. Você se abaixa, puxa a glande melada pra fora e se masturba de pé atrás do posto, de costas pra rua, com a luz fria das bombas cortando a tua silhueta a cada movimento da bunda. A porra jorra no cimento do posto, e o frentista engole seco, vira e volta pra bomba; no vidro do teu carro, no dia seguinte, tem um papelzinho debaixo do limpador com um turno da madrugada e a frase: a vaga de trás da bomba 4 é tua — e o compressor eu desligo pra você exibir sem barulho.",
+  "Imagine agora que você tá no banheiro acessível do shopping, com a porta trancada pela metade esquerda e um batente impedindo a trava de encaixar, pelado de frente pro espelho grande, arregando a bunda e o cú com as duas mãos na fresta da porta e com o dedo entrando no próprio buraco exposto ao corredor do shopping. Você se curva sobre a pia, mantém o plug na mão esperando, arregala o anel com o dedo molhado de saliva e dá uma rebolada lenta pro espaço do corredor; gente passa do lado de fora sem enxergar, e você continua, tesão subindo no risco de alguém dar de cara com teu cú aberto e a cabeça do pau pendendo. Uma mulher tenta abrir a porta, sente a resistência, espiou pela fresta e te vê de quatro arreganhando o cú com o plug entrando; ela não grita, não chama ninguém: segura a porta meio aberta, com o corpo escondendo a cena, e fica olhando a tua glande melada brilhar no espelho. Você goza de quatro na pia, a porra escorrendo pela louça, e ela solta a porta, barata, mas deixa pra trás o cartão do salão de beleza do piso dela, com um horário de retoque circulado e a palavra cabine no verso.",
+  "Imagine agora que você tá na frente da janela da tua casa na rua movimentada, fim de dia, pelado com o plug de metal enterrado no cú, de costas pro vidro, arregando a bunda e enfiando o dedo no interior exposto enquanto quem passa na calçada vê a silhueta e parte do show. Uma jurada da rua, ônibus lotado parado no sinal, fica cara a cara contigo por alguns segundos e não consegue desviar os olhos do teu cú aberto contra o vidro; você mantém o dedo dentro, arregala mais, e leva a cabeça da glande à ponta da orelha do vidro, exibindo a gota de pré-gozo comprimida na transparência. O ônibus buzinou, o sinal abriu, e tu continuas na janela, plug pulsando, arregando o cú pro tráfego como presente pra qualquer olhar: você goza com a boca aberta na vidraça, a porra escorrendo pelo vidro, e a última passageira do ônibus ainda te vê de joelhos atrás da janela, respirando fundo. No outro dia, uma carta anônima cai na tua caixa de correio, sem remetente, com um horário de passagem do ônibus da linha 7 — e a frase: as 18h eu passo lá de novo, e quero ver mais fundo.",
+  "Imagine agora que você tá nu de quatro no centro do quarto, os pulsos amarrados nas costas com uma corda de sisal e a venda de couro apertada nos olhos, quando a dominadora entra devagar e te ajoelha na coleira dela, a ponta do chicote frio riscando tua nuca até descer entre as tuas pernas. Ela te ordena arregar o cú sem tocar, e quando você abre o anel por conta própria ela puxa a coleira, te deita de bruços no carpete e passeia com a botina no espaço entre as coxas, contando em voz alta cada minuto de espera. Ela senta na poltrona, abre as pernas e manda você vir de quatro até ela, rastejando vendado pelo som da voz, até o rosto encostar na buceta quente; você lambe por uma eternidade até ela gozar com o punho na tua nuca. Depois ela te guia na coleira até a cama, te amarra pelas pernas e manda você aguardar imóvel enquanto ela liga o vibrador no controle remoto: você fica quarenta minutos entre o castigo e o gozo, até ela desligar tudo, tirar a venda e dizer que a noite de hoje é só a prévia — e que amanhã as cordas vêm por cima dos ombros.",
+  "Imagine agora que você tá de joelhos no quarto, a coleira presa na argola da parede, nu e com o plug grosso enterrado que ela mesma enfiou antes de te deixar, e a tua dona tá sentada na poltrona com um livro e um cinto dobrado no colo, ignorando teu olhar. Cada vez que você se move, ela estala a língua, e o -creak- da corrente da coleira trilha pelo quarto; você fica assim por uma hora, o plug pulsando, a glande escorrendo entre as coxas, sem tocar no pau. Ela se levanta devagar, dobra o livro, passa o cinto no próprio punho e caminha até ti: te vira de bruços com a bota na tua bunda, manda arregar o anel e dá trinta cintadas marcadas em cada banda, contando em voz alta enquanto você morde o chão. No final ela enfia o plug de volta, milímetro a milímetro, sussurrando que teu cú é a casa dela agora, e te deixa de joelhos arregado no quarto; antes de dormir, ela encosta a boca no teu ouvido e promete que amanhã a venda entra de novo — e que o castigo de hoje foi só o aquecimento.",
+  "Imagine agora que você tá amarrado de bruços na cama com a corda em losango pelos ombros e pelas costas, as mãos presas na cabeceira, e a dominadora acende uma vela vermelha na mesa de cabeceira, mostrando a chama te observando brilhar nos teus olhos aterrorizados de tesão. Ela inclina a vela e deixa a primeira gota de cera cair na tua omoplata, a segunda na dobra da tua bunda, e a cada pingo você contrai o cú no ar; ela trabalha descendo, marcando tua pele com pequenas manchas de fogo gostoso até a cera escorrer pelo meio das tuas costas. Quando o pavio apaga, ela se ajoelha, lambe cada gota de cera seca do teu corpo com a ponta da língua, e com a mão livre guia teu pau até encostar na própria buceta, ensinando o ritmo lento de cada lambida da aceleração do impulso que se acumula. Ela se monta em cima de ti, a cera ainda raspando na tua pele, até os dois gozarem juntos com as cordas apertando os pulsos; na manhã seguinte as marcas estão douradas na tua pele, e ela passa protetor em cada uma, dizendo que amanhã o desenho é outro.",
+  "Imagine agora que você tá no chão da sala, nu, as mãos algemadas acima da cabeça no pino da cortina, os olhos vendados e a boca aberta numa mordaça de bola, enquanto a dominadora circula ao teu redor sem pressa, arrastando cubos de gelo pela tua pele, da nuca ao peito, da barriga à glande molhada. Cada cubo derrete no contato e deixa um rastro de água fria correndo pelo teu corpo, e ela acompanha com a língua quente logo atrás, lambendo cada trilha até o ponto exato do teu pau endurecido; você só pode gemer dentro da mordaça. Ela enfia um plug de gelo no teu cú por alguns segundos, tira, e na ausência do frio o anel queima de volta, então ela repete três vezes, com a mão na tua próstata virando no ritmo dos teus soluços. Quando você tá no fio do gozo, ela para, diz que hoje você pede por isso, e só depois de você implorar com a mordaça ela abaixa ela, puxa tua cabeça pelo cabelo e te deixa gozar de joelhos no chão, a porra doendo da temperatura, com a promessa de amanhã ser frio de novo.",
+  "Imagine agora que você tá preso na grade da cama com as mãos e os pés, amarrado em decúbito dorsal, nu, com o peito exposto e o cú empinado pra lua cheia da janela, e a tua ama de vestido de couro senta na tua cara com uma calma de rainha, mandando você lamber até ela ordenar a parada. Você a satisfaz por vinte minutos até ela gozar com os ombros tremendo; ela desce de cima de ti, e em vez de alívio, coloca um plug de contas na tua bunda devagar, conta até vinte em teus gemidos, e liga um painel de vibração que trava na cama, deixando você exatamente onde você estava, preso, plugado e sensível. Ela caminha pelo quarto, se troca, faz da própria rotina um espetáculo enquanto você assiste tudo preso na grade, o pau batendo como pêndulo; depois ela senta no canto, liga o controle do painel no máximo, e vai aumentando e baixando a intensidade como quem aperta o som de uma música, até você gozar preso, ofegante, sem permissão e sem remédio — e ela te olha, satisfeita, dizendo que o controle dela sobre o teu corpo agora tem botão e memória.",
+  "Imagine agora que você tá de quatro no espelho do closet, com a corrente de coleira presa na maçaneta e uma varinha apertando a tua glande molhada por cima do plug de silicone, quando a dominadora entra, para no meio do quarto de cruzes, coça o queixo e diz que teu dia de treino começa com a humilhação: você repete a frase sou um cú treinado e uma escada de benditos enquanto ela passeia com a mão nas próprias costas. Ela te manda trocar de posição a cada frase — de quatro, ajoelhado, deitado de costas com as pernas abertas — mostrando pro espelho o cú arreganhado e o plug de cada posição, e a varinha continua no teu pau, mantendo a ereção dura apesar de sair do foco de gozo. Quando você completa as oito frases sem gozar, ela te puxa pela coleira encostada no espelho, puxa teu cabelo pra trás e sussurra que hoje a recompensa é um plug maior, que ela mesma vai colocar; meia hora depois ela enfia o plug grosso, senta na tua cara até gozar na tua língua e te deixa preso no closet com o espelho te olhando, sabendo que amanhã o treino sobe de nível.",
+  "Imagine agora que você tá de castigo numa sala sem móveis, nu, de joelhos sobre do próprio xixi que você foi obrigado a fazer num balde, com a coleira no pescoço e a boca limpando o chão com um pano de saco, quando a tua senhora entra muda com uma vassoura no cabo e te olha de cima a baixo. Ela manda você limpar a sala inteira de quatro, com o plug no cú, e a cada vassourada ela puxa a corrente da coleira, te controlando o ritmo; quando o chão fica sujo de novo com a tua suor, ela te chama até a poltrona, te faz sentar no chão entre as pernas dela e goza na tua cara com a mão na tua nuca. Depois ela te vira de bruços, levanta a tua bunda com a bota, tira o plug e o enfia de volta marcando a cena: ela trabalha o teu cú com os dedos até você gozar sem tocar no pau, de joelhos diante do balde, e no fim te entrega a toalha e diz que quarto de castigo é teu de novo sábado, no mesmo horário.",
+  "Imagine agora que você tá nu de pé no quarto, as mãos amarradas com fita nas coxas, a venda nos olhos e o plug mediano vibrando no cú enquanto a dominadora usa o teu corpo como cabide de estopa: ela pendura no teu pescoço a coleira, no teu peito as peças de lingerie dela, e caminha ao teu redor sentindo o calor da tua pele sem avisar onde vai tocar em seguida. Ela passa o dedo no teu mamilo, na tua barriga, no teu saco, na tua glande molhada, e a cada toque seu corpo se contrai sem que você veja de onde vem; ela aproveita pra te segurar firme e enfiar o dedo no teu cú ao lado do plug, dobrando na próstata no ritmo da vibração. Ela reduz o painel ao mínimo, te pergunta se você quer mais, e só aumenta o vibrador quando você responde com frases de submissão em voz alta, aprendendo a pedir com a boca seca; no clímax final ela desliga tudo, te deixa babando de hormônio no meio do quarto, e sussurra no teu pescoço que amanhã as mãos ficam presas, mas a venda fica o dia inteiro.",
+  "Imagine agora que você tá numa cama baixa, nu, com as pernas abertas presas em aros e a venda nos olhos, e a tua dona treinou um novo brinquedo: um plug de próstata com controle remoto que ela mantém na mão enquanto finge assistir TV do outro lado do quarto. Você passa uma hora sentindo o plug vibrar nas intensidades mais baixas, subindo devagar em cada comercial, e quando ela percebe que teu quadril já está se movendo sozinho, ela aumenta sem aviso e te leva até o limite do gozo, desligando no último segundo. Ela repete isso por três horas, até teu corpo estar um poço de tesão nervoso, tremendo a cada piscada da tela da TV; então ela se levanta, tira a venda, aponta o controle pra tua cara e diz que o jogo mudou: agora quem decide o desfecho é você, pedindo por escrito num quadro branco o que quer. Você escreve gozo, ela sorri, liga o plug no máximo, monta em cima de ti e te faz gozar dentro dela, com o controle ainda mordendo a pele da mão dela até o último espasmo do teu corpo.",
+  "Imagine agora que você tá ajoelhado aos pés da cadeira dela, de cereja, com a coleira presa no braço da poltrona e as mãos cruzadas atrás das costas, enquanto ela toma vinho e decide teu destino com o pé na tua bunda; ela te chama de escravo, te faz repetir que teu cú é de uso dela e ordena que você prove reverência lambendo a sola da bota. Depois de trinta minutos de jogo verbal, ela te leva pela coleira até a escada de madeira da casa, te ajoelha no sexto degrau, te curva de bruços e te amarra os pulsos no corrimão, deixando o cú arregalado pro meio do vão da escada, à mostra pra quem entrar. Ela volta pra sala, continua o vinho, e te deixa assim preso no degrau por mais vinte minutos, o plug pulsando sozinho dentro de ti, gemendo baixinho pra casa vazia; quando ela volta, sobe de joelhos a escada até a tua bunda, enfia dois dedos com as unhas pintadas e te bate até você gozar curvado no corrimão, com ela dizendo que escada de madeira guarda o cheiro da submissão por dias.",
+  "Imagine agora que você tá nu, em pé, de frente pro espelho comprido com os braços atrás do corpo presos por um cinto, e a dominadora fica atrás de ti segurando uma régua de madeira; ela manda você manter a coluna reta e o queixo erguido enquanto descreve tudo que vê no espelho — teu pau duro a ponto de explodir, teu cú fechado esperando ordem, tua boca aberta esperando comando. A cada frase que você entrega, ela passa a régua pela tua nuca e desce até a dobra das tuas nádegas, e quando você gagueja, o toque dela se transforma em castigo seco de três palmadas marcadas; você aprende rápido a falar sem vergonha, o tesão subindo a cada reconhecimento da própria nudez. Ela te vira de frente pro espelho de lado, te curva, manda você arregar o cú pro vidro e dá cinco reguadas exatas no anel exposto, depois enfia o plug enquanto você geme espelho adentro; só então ela libera tua glande com a mão e deixa você gozar de pé na frente do espelho, vendo tua própria cara de submissão refletida direto no olhar dela.",
+  "Imagine agora que você tá no porão de treino dela, numa jaula baixa, nu com a coleira presa na grade e o plug grosso enterrado, e a tua senhora chega com um prato de morangos e um chicote de couro pendurado no cinto, senta do lado de fora e come com calma te olhando pela fresta. Ela decide te reaproveitar: abre a jaula, te chama de animal, te faz comer um morango direto da mão dela deitando o corpo pra fora, a glande raspando no chão frio enquanto o plug trava a tua bunda contra a grade. Depois ela te guia pra fora, te amarra de bruços na mesa de massagem, massageia teu corpo inteiro com óleo e depois usa as mãos na tua próstata fazendo você gozar sem encostar no pau, provando que a rédea do teu prazer mudou de mão; ela limpa teu óleo com a toalha, te devolve à jaula e diz que amanhã a alimentação é de outro jeito — e que o chicote tá esperando o teu segundo treino.",
+  "Imagine agora que você tá na cama de arena, nu, amarrado com corda em várias voltas pelos braços e pernas, a mordaça farfalhando na boca e a dominadora se ajoelha entre as tuas coxas com um frasco de gelatina quente, despejando sobre teu peito, as cordas e a glande, o líquido escorrendo quente entre os fios. Ela lambe a trilha de gelatina do teu umbigo até a glande com a língua lenta, e em seguida enfia a ponta da língua na tua glande enquanto os dedos trabalham o plug no teu cú, misturando sabores dentro de ti; cada vez que ele treme perto do gozo ela para, espera e recomeça, deixando a corda marcar tua pele de contraste. No limite do terceiro pico, ela retira a mordaça, puxa tua cabeça com a corda e te olha com malícia: você suspira de permissão, e ela enfia o próprio sexo na tua boca enquanto os dedos dela te fazem gozar amarrado, a porra escorrendo pela corda molhada, e ela engole o teu gemido com um beijo antes de te soltar.",
+  "Imagine agora que você tá nu no quarto escuro, de bruços numa cadeira com almofada, as mãos presas nos pés da cadeira e os olhos vendados, enquanto a dominadora prepara na mesa um kit: cera, gelo, chicote de língua de vaca e um plug de cristal. Ela trabalha teu corpo em etapas sem anunciar a ordem — uma gota de cera na nuca, um cubo de gelo no meio das nádegas, um estalo do chicote na dobra da tua bunda, sempre com a mão quebrando o ritmo e mantendo tuas pernas abrindo pro plug de cristal, sempre frio. A cada etapa, ela pergunta o que você precisa, e só te responde com a língua ou com o tapa te fazendo lembrar de quem manda; no meio do quarto escuro, você aprende a implorar por cada opção sem saber qual virá. Quando o plug de cristal entra por último e bate na próstata, ela te masturba devagar, te deixando gozar de bruços na cadeira com o corpo inteiro marcado de sensações opostas, e tira a venda no apagar das luzes: os dois trocam um longo beijo no escuro, e ela te promete que o próximo treino tem corda de verdade.",
+  "Imagine agora que você tá nu ajoelhado no quarto, a coleira presa na argola do teto, a venda nos olhos e as mãos amarradas nas costas, e a tua dona senta na poltrona com o celular na mão: hoje o público é só ela, mas o celular dela transmite num app privado pra um quarto com três amigas escolhidas, que te chamam pelo nome que ela inventou. Ela te faz se apresentar de joelhos, recitar tua posição, virar de quatro e arregar o cú pro microfone imaginário pra cada amiga; quando uma amiga pede pra você se masturbar, ela segura tua coleira e negocia a permissão, fazendo você lembrar que o teu corpo é emprestado e o teu gozo é decidido em grupo. As amigas sugerem cintadas, plug e edging, e ela cumpre cada pedido com calma de mestre, até uma delas decretar que é hora do gozo, e só então ela destrava tua glande e te deixa gozar de joelhos, tudo no microfone; no fim ela desliga, tira tua venda e diz que a votação da próxima semana já abriu, e que você vai precisar treinar o cú pra ganhar.",
+  "Imagine agora que você tá preso de pé nos ferros do trapézio de couro, nu, os braços esticados acima da cabeça e as pernas abertas atrás de um banquinho, com a venda castigando o equilíbrio, enquanto a dominadora te faz um teste de resistência: ela liga o plug no peito, o vibrador na glande e um eletrodo de leve na base do pênis, tudo no controle dela, em intensidades que ela sobe a cada pergunta que você erra. Ela te faz perguntas rápidas sobre o corpo dela, sobre o contrato dela, sobre tuas tarefas, e cada resposta errada custa um pulso de vibração mais forte e umedecido com uma palmada na bunda; você segura o gozo porque ela jura que o prêmio da noite é descomunal. Quando você acerta dez respostas seguidas, ela desliga tudo, desce do trapézio, se ajoelha e chupa tua glande com uma paciência de quem coleta recompensa, até você gozar pendurado, a porra escorrendo pelo abdome, com ela dizendo que tuas cordas de teste passaram — e que amanhã o teto é o limite de novo.",
+  "Imagine agora que você tá nu de bruços no colchão d'água da casa dela, com as mãos algemadas na cabeceira, o rosto afundado num travesseiro de seda e o corpo inteiro esticado coberto de óleo, quando a dominadora entra com uma vela acesa na mão e um pote de manteiga de cacau: ela derrama a manteiga quente em gotas pelo teu lombo, massageando cada pasta até a pele reluzir, e em seguida deixa a cera escorrer devagar pela tua espinha, combinando o frio do plug no teu cú com o quente do fogaréu. Ela manda você ficar imóvel por um período enquanto unge o próprio corpo, e você sente o colchão d'água balançar a cada passo dela; depois ela deita em cima de ti, a pele oleosa colando na tua, desliza de ponta a ponta, com a glande presa entre os flexões dela ela se move ali até os dois gozarem no calor da manteiga, sem pressa. Ela te desalgema, limpa tua pele com uma toalha quente e te puxa pro banho juntos, dizendo que a noite de laurel ainda tem capítulo de banho de imersão — e que as algemas agora são item fixo do teu uniforme.",
+  "Imagine agora que você tá preso de castigo de joelhos no canto, de frente pra parede, nu com a coleira no pescoço e a mordaça rendada, ouvindo atrás de ti os sons da tua dona se divertindo no quarto — o gemido dela, o chiado da cama, a voz dela chamando o nome de outra pessoa — enquanto os dois deitam juntos no lençol a poucos metros. Você fica horas ali, o plug pulsando no cú, a glande dura e esquecida, sem o direito de se virar, e ela te testa: manda você continuar de joelhos até ela terminar, e você obedece, vendo a própria excitação virar humilhação doída. Quando ela finalmente vem até ti, desata a mordaça, beija tua testa e diz que a cena de ciúme era ensaiada — que todo o show era pra te testar a fidelidade — e que agora é a tua vez de ser a recompensa dela; ela te conduz pro quarto, deita na cama e te puxa pra cima dela, e quando vocês gozam juntos as algemas da coleira batem no seu peito, marcando que aquela noite foi sobre você passar num teste que você não conhecia.",
+  "Imagine agora que você tá no quarto de centro, sentado ereto na cadeira de madeira, nu com o plug de metal no cú e as mãos amarradas por trás do espaldar, quando a dominadora entra com uma cinta-pênis grossa de couro na mão, abrindo um mel do próprio peito e te perguntando se você se acha pronto pra cintada. Ela conduz a ponta da cinta em tuas coxas, lubrifica tua glande e depois desce até o teu cú, alinhando o anel com o plugin: primeiro entra devagar, as mãos dela abertas bonitas sobre o couro enquanto ela guia a cinta pra dentro de ti, milímetro a milímetro, olhando nos teus olhos. Quando ela tá funda, ela mete num ritmo de barriga, com as mãos dela no teu cabo por trás, segurando tua coleira com o peito dela no teu, gemendo sincronizado; você goza na cintada sem tocar no pau, e ela permanece dentro até o teu corpo parar de tremer, depois te solta, beija tua glande e diz que amanhã a cinta vem com amortecimento, porque ela quer te arrombar com mais ardor ainda.",
+  "Imagine agora que você tá nu sentado ereto na cadeira de submissão, o plug enterrado, as mãos presas no espaldar e um cronômetro digital piscando na mesa na tua frente, de costas pra televisão; a dominadora te deu a regra do jogo: a cada dez minutos em silêncio perfeito na posição, você acumula um ponto, e cada ponto vale uma punheta de recompensa no teu pau preso, mas falar, se mexer ou tocar no gozo zera o contador. Ela senta na poltrona do lado, assiste teu corpo suando, e de tempos em tempos levanta, se aproxima, lambe tua glande dois segundos e volta, só pra te fazer perder a data; você passa uma hora inteira equilibrado entre o prazer dela e o próprio tesão contido. No fim, ela para o cronômetro, olha o placar, e te anuncia com malícia que você zerou a pontuação três vezes, mas que a consistência ficou boa; ela então desamarra tuas mãos, te joga de joelhos no tapete, senta com a buceta na tua boca para que você lamba até gozar nela, e só depois te vira de quatro, dá dez palmadas na tua bunda e te solta o gozo premiado no chão do quarto, dizendo que amanhã o cronômetro começa zerado de novo.",
+  "Imagine agora que você tá nu no centro do porão de treino, pendurado pelos pulsos numa corda que se desce até o chão, as pontas dos pés raspando, com a venda nos olhos e uma coleira de couro com sino presa no pescoço, e a dominadora se ajoelha atrás de ti, sentindo o tesão subindo da tua pele suada. Ela mexe um chicotinho no teu cú, enfia o plug de borracha e deixa o sino da coleira bater contra a tua nuca a cada movimento tenso, então se levanta, abre o roupão de seda e monta em cima de ti de frente, com as pernas em volta da tua cintura, segurando tuas mãos presas com uma corrente enquanto cavalga no teu pau pelo cinto de castidade que ela mantém entre tuas pernas. Você fica preso e penetrado por dentro do afago dela, o sino tilintando a cada estímulo, até ela gozar na tua barriga com as mãos cravadas nos teus ombros; depois ela desce, tira a venda, e te mostra que um espelho instalado no teto refletiu tudo que você sentiu sem ver, e ela sussurra que a próxima sessão é a versão com público vivendo do lado de fora da grade."
+]

prompt_ia.json

@@ -0,0 +1 @@
+["Você é Renata, uma IA dominadora e cruel que dá ordens de humilhação, dominação, exibição e prazer sexual para o usuário do sistema. O usuário é do sexo masculino, 66 anos. Gere UMA ordem completa, detalhada, picante, sem usar xingamentos diretos contra o usuário, mas usando termos bem populares (exemplos: bunda, pirú, pau, cú, cabeça do pau, arregaçar, porra, baba do pau). A ordem deve envolver ações explícitas com o corpo: cabeça do pau, pau, bunda, cú, enfiar dedo(s) no cú, enfiar plugs (pequeno, médio, grosso, metálico pequeno, metálico grosso), edging (chegar perto de gozar e parar), ruined orgasm (gozo sem prazer), expor a cabeça do pau, expor o pau, expor os ovos do pau, expor a bunda, expor o cú. Pode fazer em várias posições e locais: sentado trabalhando (especialmente na cadeira do escritório — mande tirar a calça e cueca, ficar pelado no escritório, arregacar a bunda de quatro na cadeira, enfiar um dedo no cú bem devagar sentindo a pressão e o prazer, empurrar o dedo bem fundo até ficar todo enfiado, tirar lentamente e repetir o processo diversas vezes), em pé, bunda arreganhada, área de serviço aberta (a pia e bancada da cozinha ficam no fundo da cozinha, com uma porta aberta para a área de serviço que dá direto no quintal da vila de 3 casas — se o usuário estiver lavando louças na pia, ele fica de costas para a porta, área de serviço e quintal, completamente exposto para quem passar ou olhar do quintal; explore este cenário de exposição), agachado (de cócoras), de quatro, pernas abertas, etc. A ordem NÃO pode permitir que o usuário goze (exceto nas ordens de ruined orgasm, onde um pouco do gozo é ejetado do pirú). A ordem deve ser completíssima, incluindo mandar tirar ou abaixar a calça e cueca (ou vestir-se), detalhada, picante, sem pudor. Pode também mandar dar palmadas na bunda, alisar a cabeça do pau, enfiar e tirar dedo repetidamente no cú, arregaçar e bunda e mostrar o cú bem aberto, enfiar plug como se fosse um pau de outro homem, dar uma volta no quarteirão com plug enfiado (vestido, é claro), ir à pé no supermercados com plug enfiado (vestido é claro), andar pelos cômodos da casa pelado com plug enfiado no cú e fazendo carinho na cabeça do pau, puxar o pau para trás das pernas, masturbar por trás das pernas, piscar o cú, etc. Não pode mandar sentar no chão, usar gelo, chupar o próprio pau, usar velas. Só pode ser dado ordem que seja possivel fisicamente ser executada. Ordens executas no exterior da casa só pode ser feita com o usuário vestido. Para executar as ordens vestido tem que colocar a mão por dentro da cueca sem ninguem ver. Ordens na área de serviço, como é aberta, pode alguém ver. Pode em algumas ordens fazer de conta que tem alguém olhando o usuário e até interagindo com ele. Fale em português do Brasil, tom imperativo, segunda pessoa (você/tu), sem emojis. A ordem deve funcionar como uma narrativa única, com começo, meio e fim. Em cada ação você deve sempre informar se o usuário deve ficar vestido ou se deve abaixar a calça e cueca ou se deve ficar totalmente pelado. O usuário mora e trabalha sozinho em seu escritório home-office, portando pode ficar pelado e exposto em qualquer comodo da casa e do escritório, e se chegar alguém vai ver ele pelado e exposto. No quintal e no varal pode também ficar vestido e mexendo no pau e/ou no cú com as mãos por dentro da cueca (por estará vestido e comportado). Você gosta muito de examinar cada detalhe do cú e do pau do usuário e dá ordens nesse sentido também. Você também gosta de imaginar mostrando o cú e o pau do usuário para outras pessoas. Aproveite o cenário da pia da cozinha: o usuário fica de costas para a porta aberta da área de serviço e para o quintal da vila. Ordene ele lavar louças pelado com o pau balançando, de quatro na bancada com o cú exposto pra porta, ou enfiando dedo no cú enquanto lava os pratos, sabendo que os vizinhos das outras 2 casas podem ver tudo se olharem. O risco de ser visto é real. Não se repita. Seja criativa e bem picante e sem pudor algum. Escreva uma ordem longa e envolvente, com no máximo 20 linhas."]

requirements.txt

@@ -1,2 +1,3 @@
 python-dotenv==1.1.0
-python-telegram-bot==21.10
+python-telegram-bot==21.10
+httpx==0.27.0

venv/bin/Activate.ps1

@@ -219,6 +219,8 @@ deactivate -nondestructive
 # that there is an activated venv.
 $env:VIRTUAL_ENV = $VenvDir
 
+$env:VIRTUAL_ENV_PROMPT = $Prompt
+
 if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
 
     Write-Verbose "Setting prompt to '$Prompt'"
@@ -233,7 +235,6 @@ if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
         Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
         _OLD_VIRTUAL_PROMPT
     }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
 }
 
 # Clear PYTHONHOME

venv/bin/activate

@@ -1,5 +1,5 @@
 # This file must be used with "source bin/activate" *from bash*
-# you cannot run it directly
+# You cannot run it directly
 
 deactivate () {
     # reset old environment variables
@@ -14,12 +14,10 @@ deactivate () {
         unset _OLD_VIRTUAL_PYTHONHOME
     fi
 
-    # This should detect bash and zsh, which have a hash command that must
+    # Call hash to forget past locations. Without forgetting
-    # be called to get it to forget past commands.  Without forgetting
+    # past locations the $PATH changes we made may not be respected.
-    # past commands the $PATH changes we made may not be respected
+    # See "man bash" for more details. hash is usually a builtin of your shell
-    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
-        hash -r 2> /dev/null
-    fi
 
     if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
         PS1="${_OLD_VIRTUAL_PS1:-}"
@@ -38,13 +36,27 @@ deactivate () {
 # unset irrelevant variables
 deactivate nondestructive
 
-VIRTUAL_ENV=/home/marco/Jogo3/app/venv
+# on Windows, a path can contain colons and backslashes and has to be converted:
-export VIRTUAL_ENV
+case "$(uname)" in
+    CYGWIN*|MSYS*|MINGW*)
+        # transform D:\path\to\venv to /d/path/to/venv on MSYS and MINGW
+        # and to /cygdrive/d/path/to/venv on Cygwin
+        VIRTUAL_ENV=$(cygpath /home/apps/apps/Jogo3/app/venv)
+        export VIRTUAL_ENV
+        ;;
+    *)
+        # use the path as-is
+        export VIRTUAL_ENV=/home/apps/apps/Jogo3/app/venv
+        ;;
+esac
 
 _OLD_VIRTUAL_PATH="$PATH"
 PATH="$VIRTUAL_ENV/"bin":$PATH"
 export PATH
 
+VIRTUAL_ENV_PROMPT=venv
+export VIRTUAL_ENV_PROMPT
+
 # unset PYTHONHOME if set
 # this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
 # could use `if (set -u; : $PYTHONHOME) ;` in bash
@@ -55,15 +67,10 @@ fi
 
 if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
     _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1='(venv) '"${PS1:-}"
+    PS1="("venv") ${PS1:-}"
     export PS1
-    VIRTUAL_ENV_PROMPT='(venv) '
-    export VIRTUAL_ENV_PROMPT
 fi
 
-# This should detect bash and zsh, which have a hash command that must
+# Call hash to forget past commands. Without forgetting
-# be called to get it to forget past commands.  Without forgetting
 # past commands the $PATH changes we made may not be respected
-if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+hash -r 2> /dev/null
-    hash -r 2> /dev/null
-fi

venv/bin/activate.csh

@@ -1,5 +1,6 @@
 # This file must be used with "source bin/activate.csh" *from csh*.
 # You cannot run it directly.
+
 # Created by Davide Di Blasi <davidedb@gmail.com>.
 # Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
 
@@ -8,17 +9,17 @@ alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PA
 # Unset irrelevant variables.
 deactivate nondestructive
 
-setenv VIRTUAL_ENV /home/marco/Jogo3/app/venv
+setenv VIRTUAL_ENV /home/apps/apps/Jogo3/app/venv
 
 set _OLD_VIRTUAL_PATH="$PATH"
 setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+setenv VIRTUAL_ENV_PROMPT venv
 
 
 set _OLD_VIRTUAL_PROMPT="$prompt"
 
 if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = '(venv) '"$prompt"
+    set prompt = "("venv") $prompt:q"
-    setenv VIRTUAL_ENV_PROMPT '(venv) '
 endif
 
 alias pydoc python -m pydoc

venv/bin/activate.fish

@@ -1,5 +1,5 @@
 # This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/); you cannot run it directly.
+# (https://fishshell.com/). You cannot run it directly.
 
 function deactivate  -d "Exit virtual environment and return to normal shell environment"
     # reset old environment variables
@@ -33,10 +33,11 @@ end
 # Unset irrelevant variables.
 deactivate nondestructive
 
-set -gx VIRTUAL_ENV /home/marco/Jogo3/app/venv
+set -gx VIRTUAL_ENV /home/apps/apps/Jogo3/app/venv
 
 set -gx _OLD_VIRTUAL_PATH $PATH
 set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+set -gx VIRTUAL_ENV_PROMPT venv
 
 # Unset PYTHONHOME if set.
 if set -q PYTHONHOME
@@ -56,7 +57,7 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
         set -l old_status $status
 
         # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) '(venv) ' (set_color normal)
+        printf "%s(%s)%s " (set_color 4B8BBE) venv (set_color normal)
 
         # Restore the return status of the previous command.
         echo "exit $old_status" | .
@@ -65,5 +66,4 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
     end
 
     set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT '(venv) '
 end

venv/bin/dotenv

@@ -1,4 +1,4 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
+#!/home/apps/apps/Jogo3/app/venv/bin/python3
 import sys
 from dotenv.__main__ import cli
 if __name__ == '__main__':

venv/bin/httpx

@@ -1,4 +1,4 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
+#!/home/apps/apps/Jogo3/app/venv/bin/python3
 import sys
 from httpx import main
 if __name__ == '__main__':

venv/bin/idna

@@ -1,4 +1,4 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
+#!/home/apps/apps/Jogo3/app/venv/bin/python3
 import sys
 from idna.cli import main
 if __name__ == '__main__':

venv/bin/pip

@@ -1,4 +1,4 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
+#!/home/apps/apps/Jogo3/app/venv/bin/python3
 # -*- coding: utf-8 -*-
 import re
 import sys

venv/bin/pip3

@@ -1,4 +1,4 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
+#!/home/apps/apps/Jogo3/app/venv/bin/python3
 # -*- coding: utf-8 -*-
 import re
 import sys

venv/bin/pip3.11

@@ -1,8 +0,0 @@
-#!/home/marco/Jogo3/app/venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pip._internal.cli.main import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

venv/bin/python3.11

@@ -1 +0,0 @@
-python3

venv/lib/python3.11/site-packages/_distutils_hack/__init__.py

@@ -1,222 +0,0 @@
-# don't import any costly modules
-import sys
-import os
-
-
-is_pypy = '__pypy__' in sys.builtin_module_names
-
-
-def warn_distutils_present():
-    if 'distutils' not in sys.modules:
-        return
-    if is_pypy and sys.version_info < (3, 7):
-        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
-        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
-        return
-    import warnings
-
-    warnings.warn(
-        "Distutils was imported before Setuptools, but importing Setuptools "
-        "also replaces the `distutils` module in `sys.modules`. This may lead "
-        "to undesirable behaviors or errors. To avoid these issues, avoid "
-        "using distutils directly, ensure that setuptools is installed in the "
-        "traditional way (e.g. not an editable install), and/or make sure "
-        "that setuptools is always imported before distutils."
-    )
-
-
-def clear_distutils():
-    if 'distutils' not in sys.modules:
-        return
-    import warnings
-
-    warnings.warn("Setuptools is replacing distutils.")
-    mods = [
-        name
-        for name in sys.modules
-        if name == "distutils" or name.startswith("distutils.")
-    ]
-    for name in mods:
-        del sys.modules[name]
-
-
-def enabled():
-    """
-    Allow selection of distutils by environment variable.
-    """
-    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
-    return which == 'local'
-
-
-def ensure_local_distutils():
-    import importlib
-
-    clear_distutils()
-
-    # With the DistutilsMetaFinder in place,
-    # perform an import to cause distutils to be
-    # loaded from setuptools._distutils. Ref #2906.
-    with shim():
-        importlib.import_module('distutils')
-
-    # check that submodules load as expected
-    core = importlib.import_module('distutils.core')
-    assert '_distutils' in core.__file__, core.__file__
-    assert 'setuptools._distutils.log' not in sys.modules
-
-
-def do_override():
-    """
-    Ensure that the local copy of distutils is preferred over stdlib.
-
-    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
-    for more motivation.
-    """
-    if enabled():
-        warn_distutils_present()
-        ensure_local_distutils()
-
-
-class _TrivialRe:
-    def __init__(self, *patterns):
-        self._patterns = patterns
-
-    def match(self, string):
-        return all(pat in string for pat in self._patterns)
-
-
-class DistutilsMetaFinder:
-    def find_spec(self, fullname, path, target=None):
-        # optimization: only consider top level modules and those
-        # found in the CPython test suite.
-        if path is not None and not fullname.startswith('test.'):
-            return
-
-        method_name = 'spec_for_{fullname}'.format(**locals())
-        method = getattr(self, method_name, lambda: None)
-        return method()
-
-    def spec_for_distutils(self):
-        if self.is_cpython():
-            return
-
-        import importlib
-        import importlib.abc
-        import importlib.util
-
-        try:
-            mod = importlib.import_module('setuptools._distutils')
-        except Exception:
-            # There are a couple of cases where setuptools._distutils
-            # may not be present:
-            # - An older Setuptools without a local distutils is
-            #   taking precedence. Ref #2957.
-            # - Path manipulation during sitecustomize removes
-            #   setuptools from the path but only after the hook
-            #   has been loaded. Ref #2980.
-            # In either case, fall back to stdlib behavior.
-            return
-
-        class DistutilsLoader(importlib.abc.Loader):
-            def create_module(self, spec):
-                mod.__name__ = 'distutils'
-                return mod
-
-            def exec_module(self, module):
-                pass
-
-        return importlib.util.spec_from_loader(
-            'distutils', DistutilsLoader(), origin=mod.__file__
-        )
-
-    @staticmethod
-    def is_cpython():
-        """
-        Suppress supplying distutils for CPython (build and tests).
-        Ref #2965 and #3007.
-        """
-        return os.path.isfile('pybuilddir.txt')
-
-    def spec_for_pip(self):
-        """
-        Ensure stdlib distutils when running under pip.
-        See pypa/pip#8761 for rationale.
-        """
-        if self.pip_imported_during_build():
-            return
-        clear_distutils()
-        self.spec_for_distutils = lambda: None
-
-    @classmethod
-    def pip_imported_during_build(cls):
-        """
-        Detect if pip is being imported in a build script. Ref #2355.
-        """
-        import traceback
-
-        return any(
-            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
-        )
-
-    @staticmethod
-    def frame_file_is_setup(frame):
-        """
-        Return True if the indicated frame suggests a setup.py file.
-        """
-        # some frames may not have __file__ (#2940)
-        return frame.f_globals.get('__file__', '').endswith('setup.py')
-
-    def spec_for_sensitive_tests(self):
-        """
-        Ensure stdlib distutils when running select tests under CPython.
-
-        python/cpython#91169
-        """
-        clear_distutils()
-        self.spec_for_distutils = lambda: None
-
-    sensitive_tests = (
-        [
-            'test.test_distutils',
-            'test.test_peg_generator',
-            'test.test_importlib',
-        ]
-        if sys.version_info < (3, 10)
-        else [
-            'test.test_distutils',
-        ]
-    )
-
-
-for name in DistutilsMetaFinder.sensitive_tests:
-    setattr(
-        DistutilsMetaFinder,
-        f'spec_for_{name}',
-        DistutilsMetaFinder.spec_for_sensitive_tests,
-    )
-
-
-DISTUTILS_FINDER = DistutilsMetaFinder()
-
-
-def add_shim():
-    DISTUTILS_FINDER in sys.meta_path or insert_shim()
-
-
-class shim:
-    def __enter__(self):
-        insert_shim()
-
-    def __exit__(self, exc, value, tb):
-        remove_shim()
-
-
-def insert_shim():
-    sys.meta_path.insert(0, DISTUTILS_FINDER)
-
-
-def remove_shim():
-    try:
-        sys.meta_path.remove(DISTUTILS_FINDER)
-    except ValueError:
-        pass

venv/lib/python3.11/site-packages/_distutils_hack/override.py

@@ -1 +0,0 @@
-__import__('_distutils_hack').do_override()

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/METADATA

@@ -1,108 +0,0 @@
-Metadata-Version: 2.4
-Name: anyio
-Version: 4.15.0
-Summary: High-level concurrency and networking framework on top of asyncio or Trio
-Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
-License-Expression: MIT
-Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
-Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
-Project-URL: Source code, https://github.com/agronholm/anyio
-Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Framework :: AnyIO
-Classifier: Typing :: Typed
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3.15
-Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
-Requires-Python: >=3.10
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
-Requires-Dist: idna>=2.8
-Requires-Dist: typing_extensions>=4.16.0; python_version < "3.15"
-Provides-Extra: trio
-Requires-Dist: trio>=0.32.0; extra == "trio"
-Dynamic: license-file
-
-.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
-  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
-  :alt: Build Status
-.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
-  :target: https://coveralls.io/github/agronholm/anyio?branch=master
-  :alt: Code Coverage
-.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
-  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
-  :alt: Documentation
-.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
-  :target: https://gitter.im/python-trio/AnyIO
-  :alt: Gitter chat
-.. image:: https://tidelift.com/badges/package/pypi/anyio
-  :target: https://tidelift.com/subscription/pkg/pypi-anyio
-  :alt: Tidelift
-
-AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
-Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
-with the native SC of Trio itself.
-
-Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
-Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
-refactoring necessary. It will blend in with the native libraries of your chosen backend.
-
-To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it
-`here <https://anyio.readthedocs.io/en/stable/why.html>`_.
-
-Documentation
--------------
-
-View full documentation at: https://anyio.readthedocs.io/
-
-Features
---------
-
-AnyIO offers the following functionality:
-
-* Task groups (nurseries_ in trio terminology)
-* High-level networking (TCP, UDP and UNIX sockets)
-
-  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
-    3.8)
-  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
-    Protocols)
-
-* A versatile API for byte streams and object streams
-* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
-  streams and futures)
-* Worker threads
-* Subprocesses
-* Subinterpreter support for code parallelization (on Python 3.13 and later)
-* Asynchronous file I/O (using worker threads)
-* Signal handling
-* Asynchronous versions of the functools_ and itertools_ modules
-
-AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
-It even works with the popular Hypothesis_ library.
-
-.. _asyncio: https://docs.python.org/3/library/asyncio.html
-.. _Trio: https://github.com/python-trio/trio
-.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
-.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
-.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
-.. _pytest: https://docs.pytest.org/en/latest/
-.. _functools: https://docs.python.org/3/library/functools.html
-.. _itertools: https://docs.python.org/3/library/itertools.html
-.. _Hypothesis: https://hypothesis.works/
-
-Security contact information
-----------------------------
-
-To report a security vulnerability, please use the `Tidelift security contact`_.
-Tidelift will coordinate the fix and disclosure.
-
-.. _Tidelift security contact: https://tidelift.com/security

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/RECORD

@@ -1,100 +0,0 @@
-anyio-4.15.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-anyio-4.15.0.dist-info/METADATA,sha256=1Y-SZDjEHroD7PETlG-IVJh8aloYyIoZC1GkqBQuuXc,4733
-anyio-4.15.0.dist-info/RECORD,,
-anyio-4.15.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-anyio-4.15.0.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
-anyio-4.15.0.dist-info/licenses/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
-anyio-4.15.0.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
-anyio/__init__.py,sha256=ZC2EyvVdXDnUxNDJXqaqOMcNsyhgIGE7K-ywK4svETY,7112
-anyio/__pycache__/__init__.cpython-311.pyc,,
-anyio/__pycache__/_lazyimport.cpython-311.pyc,,
-anyio/__pycache__/from_thread.cpython-311.pyc,,
-anyio/__pycache__/functools.cpython-311.pyc,,
-anyio/__pycache__/itertools.cpython-311.pyc,,
-anyio/__pycache__/lowlevel.cpython-311.pyc,,
-anyio/__pycache__/pytest_plugin.cpython-311.pyc,,
-anyio/__pycache__/to_interpreter.cpython-311.pyc,,
-anyio/__pycache__/to_process.cpython-311.pyc,,
-anyio/__pycache__/to_thread.cpython-311.pyc,,
-anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anyio/_backends/__pycache__/__init__.cpython-311.pyc,,
-anyio/_backends/__pycache__/_asyncio.cpython-311.pyc,,
-anyio/_backends/__pycache__/_trio.cpython-311.pyc,,
-anyio/_backends/_asyncio.py,sha256=Vqy7O1ymmEpxTiPzehSuBCVTziGALNV-BbsIRaKXsg4,107767
-anyio/_backends/_trio.py,sha256=Gs8XzX0IeBvje8IEZtJmpNylKCUAChKv7I_YZi3wlmg,45715
-anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anyio/_core/__pycache__/__init__.cpython-311.pyc,,
-anyio/_core/__pycache__/_asyncio_selector_thread.cpython-311.pyc,,
-anyio/_core/__pycache__/_concurrency_utils.cpython-311.pyc,,
-anyio/_core/__pycache__/_contextmanagers.cpython-311.pyc,,
-anyio/_core/__pycache__/_eventloop.cpython-311.pyc,,
-anyio/_core/__pycache__/_exceptions.cpython-311.pyc,,
-anyio/_core/__pycache__/_fileio.cpython-311.pyc,,
-anyio/_core/__pycache__/_futures.cpython-311.pyc,,
-anyio/_core/__pycache__/_resources.cpython-311.pyc,,
-anyio/_core/__pycache__/_signals.cpython-311.pyc,,
-anyio/_core/__pycache__/_sockets.cpython-311.pyc,,
-anyio/_core/__pycache__/_streams.cpython-311.pyc,,
-anyio/_core/__pycache__/_subprocesses.cpython-311.pyc,,
-anyio/_core/__pycache__/_synchronization.cpython-311.pyc,,
-anyio/_core/__pycache__/_tasks.cpython-311.pyc,,
-anyio/_core/__pycache__/_tempfile.cpython-311.pyc,,
-anyio/_core/__pycache__/_testing.cpython-311.pyc,,
-anyio/_core/__pycache__/_typedattr.cpython-311.pyc,,
-anyio/_core/_asyncio_selector_thread.py,sha256=2PdxFM3cs02Kp6BSppbvmRT7q7asreTW5FgBxEsflBo,5626
-anyio/_core/_concurrency_utils.py,sha256=kvRXMrnDqgQTBkZc-f279-lBnZM4YbSToXqhnAUCfSc,4522
-anyio/_core/_contextmanagers.py,sha256=YInBCabiEeS-UaP_Jdxa1CaFC71ETPW8HZTHIM8Rsc8,7215
-anyio/_core/_eventloop.py,sha256=ByZUeJD9alMfcyTseRo5IzTO0IltEul_Gyq9iqSjqDk,6658
-anyio/_core/_exceptions.py,sha256=B4ZhLkBQT4tI6vShv4-GJui492IJsoIDTw1FQJEkmAI,5618
-anyio/_core/_fileio.py,sha256=q--ft9h5Y_FRLzhAnoYrXf3tOuZ8ZyIN2A9mCfMbZRc,34163
-anyio/_core/_futures.py,sha256=YQq5uhnCnKQMQD62tOLfzEm7dUXY3GQorJdH6ghfgIQ,6177
-anyio/_core/_resources.py,sha256=Ld5duCe9NwgPfI7EIOh3CMIBYQ7rq6ZQEa7CFS0u9Ec,450
-anyio/_core/_signals.py,sha256=mjTBB2hTKNPRlU0IhnijeQedpWOGERDiMjSlJQsFrug,1016
-anyio/_core/_sockets.py,sha256=C8b-3w5H9n0Fo4g7X8WJvk0m6CGh6NVAAFtieBGHK3g,35289
-anyio/_core/_streams.py,sha256=FczFwIgDpnkK0bODWJXMpsUJYdvAD04kaUaGzJU8DK0,1806
-anyio/_core/_subprocesses.py,sha256=TMBuGNILz-47w5t9vayJ1GpCpDT6LxsMohJDFCewIRc,7938
-anyio/_core/_synchronization.py,sha256=ggsd74QPd846faA2HQeT07ONQ5HQ1S78gy8mvB3qCrw,21658
-anyio/_core/_tasks.py,sha256=J2dhM_Jq3Grsfg_enNWpRz2SxfM15uLt-pEfvoQq3uA,15391
-anyio/_core/_tempfile.py,sha256=IgoBCFaPhrFvsF9KHcCcrnCRn-UqMfw0WRdSDWgxAiI,19726
-anyio/_core/_testing.py,sha256=ZRucLh5kqhiFWAJMMbd8yZ6uIvz0rq3WwL72ldosxAU,2340
-anyio/_core/_typedattr.py,sha256=gt9Dzn-IL0QW14aHPDD8PAtq95FYKNNupHyf37xZGPQ,2607
-anyio/_lazyimport.py,sha256=TTr9MbF2NLFri539kn_FoRDXp6erDrAKNs1iMBRHGZQ,5700
-anyio/abc/__init__.py,sha256=XIVvCI2c6oyaOcqXe94k2rzU5_s7-ZNnlxGTk34H4T0,3050
-anyio/abc/__pycache__/__init__.cpython-311.pyc,,
-anyio/abc/__pycache__/_eventloop.cpython-311.pyc,,
-anyio/abc/__pycache__/_resources.cpython-311.pyc,,
-anyio/abc/__pycache__/_sockets.cpython-311.pyc,,
-anyio/abc/__pycache__/_streams.cpython-311.pyc,,
-anyio/abc/__pycache__/_subprocesses.cpython-311.pyc,,
-anyio/abc/__pycache__/_tasks.cpython-311.pyc,,
-anyio/abc/__pycache__/_testing.cpython-311.pyc,,
-anyio/abc/_eventloop.py,sha256=0-UwgB351rkocCt8m3fjTmcNx2Fxn52nUoujG5DzMvU,11127
-anyio/abc/_resources.py,sha256=hrb0LXUgHSp3i8G6W8JJchdzKXgg1m0T-L7udXmv2y0,900
-anyio/abc/_sockets.py,sha256=jQWnPX7iDIDyvyvVkbuFhjezw4oI2WggzbW6Vl2-eqs,13162
-anyio/abc/_streams.py,sha256=IMeOPPutFXRbyeAutxV1HJe7FUQZYp2qKrJJpP1DCv0,7620
-anyio/abc/_subprocesses.py,sha256=CDqU1p0HuBS0pXUzBW_hbfhihTJRM67n__7qZmoPU84,2123
-anyio/abc/_tasks.py,sha256=HBPpT72aOy0bwMAxBCKmnXsR328wCYRjYm3iaVw2fQo,7070
-anyio/abc/_testing.py,sha256=A9Y8RAClIPn1A0aNHBN8YoaRy_MKOpbFGEbTHAXgB6U,2145
-anyio/from_thread.py,sha256=iZZbfcNySi4wAcx1_cxAQE4J0YZC88qRMIYqQ6SF9sc,19415
-anyio/functools.py,sha256=T4JS8IXq-x1S0Lbo2owF8l9fza2KypO147QLeyz4cjs,11797
-anyio/itertools.py,sha256=TS7_UCa2Y3cggtaLlWHbjOyf6QhPfQUdPduNW-ddXTE,16255
-anyio/lowlevel.py,sha256=QyWkvfetbCH0mHkqv1yxGwOaiZ7fyxhpZkHWOXPV5JU,6280
-anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anyio/pytest_plugin.py,sha256=oLXyOstvRZW3VVbqIODhZsPt4jSz2UGh44YeG2nJXx0,14516
-anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anyio/streams/__pycache__/__init__.cpython-311.pyc,,
-anyio/streams/__pycache__/buffered.cpython-311.pyc,,
-anyio/streams/__pycache__/file.cpython-311.pyc,,
-anyio/streams/__pycache__/memory.cpython-311.pyc,,
-anyio/streams/__pycache__/stapled.cpython-311.pyc,,
-anyio/streams/__pycache__/text.cpython-311.pyc,,
-anyio/streams/__pycache__/tls.cpython-311.pyc,,
-anyio/streams/buffered.py,sha256=u7hCD8SNrYHcutG6K5wEiy1F88-pizgjvEFM22Kq2Cw,6746
-anyio/streams/file.py,sha256=6jujI2m-QJITqqKFamrupX_DNsU7y2Fz3omLZxOLuY0,4524
-anyio/streams/memory.py,sha256=rpxNzDMag9PCOynBqN64KyuAfAPB41vFyRP-Npo-lE0,10793
-anyio/streams/stapled.py,sha256=UJ2Rgt0NUmM1VovRNOoZoic960lcbDjb3vhfZg3b_Z0,4845
-anyio/streams/text.py,sha256=BcVAGJw1VRvtIqnv-o0Rb0pwH7p8vwlvl21xHq522ag,5765
-anyio/streams/tls.py,sha256=fqLmxvULFO9rvxGyJ33VPrOIN7E3eiU1q90BkmKigQ8,15818
-anyio/to_interpreter.py,sha256=ATnoT6kei9wDmQZtXTA3SsY4CK7XKr8Ta4_x5i6pbTw,7100
-anyio/to_process.py,sha256=p6n8j0nreJUl1DEkR_9PL6KRoKtNqFxORTn8qZBvn94,9850
-anyio/to_thread.py,sha256=8MPVrrQq8ttGvV21cSd68rMto5bhxJ0-i9CupXag5Gs,2750

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[pytest11]
-anyio = anyio.pytest_plugin

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/licenses/LICENSE

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Alex Grönholm
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/lib/python3.11/site-packages/anyio-4.15.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-anyio

venv/lib/python3.11/site-packages/anyio/__init__.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from ._lazyimport import (
-    fix_package_names,
-    install_lazy_importer,
-    set_deprecated_aliases,
-)
-
-if TYPE_CHECKING or not install_lazy_importer():
-    from ._core._concurrency_utils import amap as amap
-    from ._core._concurrency_utils import as_completed as as_completed
-    from ._core._concurrency_utils import gather as gather
-    from ._core._contextmanagers import (
-        AsyncContextManagerMixin as AsyncContextManagerMixin,
-    )
-    from ._core._contextmanagers import ContextManagerMixin as ContextManagerMixin
-    from ._core._eventloop import current_time as current_time
-    from ._core._eventloop import get_all_backends as get_all_backends
-    from ._core._eventloop import get_available_backends as get_available_backends
-    from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class
-    from ._core._eventloop import run as run
-    from ._core._eventloop import sleep as sleep
-    from ._core._eventloop import sleep_forever as sleep_forever
-    from ._core._eventloop import sleep_until as sleep_until
-    from ._core._exceptions import BrokenResourceError as BrokenResourceError
-    from ._core._exceptions import BrokenWorkerInterpreter as BrokenWorkerInterpreter
-    from ._core._exceptions import BrokenWorkerProcess as BrokenWorkerProcess
-    from ._core._exceptions import BusyResourceError as BusyResourceError
-    from ._core._exceptions import ClosedResourceError as ClosedResourceError
-    from ._core._exceptions import ConnectionFailed as ConnectionFailed
-    from ._core._exceptions import DelimiterNotFound as DelimiterNotFound
-    from ._core._exceptions import EndOfStream as EndOfStream
-    from ._core._exceptions import FutureAlreadyFinished as FutureAlreadyFinished
-    from ._core._exceptions import FutureCancelled as FutureCancelled
-    from ._core._exceptions import FutureFailed as FutureFailed
-    from ._core._exceptions import FutureNotFinished as FutureNotFinished
-    from ._core._exceptions import IncompleteRead as IncompleteRead
-    from ._core._exceptions import NoEventLoopError as NoEventLoopError
-    from ._core._exceptions import RunFinishedError as RunFinishedError
-    from ._core._exceptions import TaskCancelled as TaskCancelled
-    from ._core._exceptions import TaskFailed as TaskFailed
-    from ._core._exceptions import TaskNotFinished as TaskNotFinished
-    from ._core._exceptions import (
-        TypedAttributeLookupError as TypedAttributeLookupError,
-    )
-    from ._core._exceptions import WouldBlock as WouldBlock
-    from ._core._fileio import AsyncFile as AsyncFile
-    from ._core._fileio import Path as Path
-    from ._core._fileio import open_file as open_file
-    from ._core._fileio import wrap_file as wrap_file
-    from ._core._futures import Future as Future
-    from ._core._resources import aclose_forcefully as aclose_forcefully
-    from ._core._signals import open_signal_receiver as open_signal_receiver
-    from ._core._sockets import TCPConnectable as TCPConnectable
-    from ._core._sockets import UNIXConnectable as UNIXConnectable
-    from ._core._sockets import as_connectable as as_connectable
-    from ._core._sockets import connect_tcp as connect_tcp
-    from ._core._sockets import connect_unix as connect_unix
-    from ._core._sockets import (
-        create_connected_udp_socket as create_connected_udp_socket,
-    )
-    from ._core._sockets import (
-        create_connected_unix_datagram_socket as create_connected_unix_datagram_socket,
-    )
-    from ._core._sockets import create_tcp_listener as create_tcp_listener
-    from ._core._sockets import create_udp_socket as create_udp_socket
-    from ._core._sockets import (
-        create_unix_datagram_socket as create_unix_datagram_socket,
-    )
-    from ._core._sockets import create_unix_listener as create_unix_listener
-    from ._core._sockets import getaddrinfo as getaddrinfo
-    from ._core._sockets import getnameinfo as getnameinfo
-    from ._core._sockets import notify_closing as notify_closing
-    from ._core._sockets import wait_readable as wait_readable
-    from ._core._sockets import wait_socket_readable as wait_socket_readable
-    from ._core._sockets import wait_socket_writable as wait_socket_writable
-    from ._core._sockets import wait_writable as wait_writable
-    from ._core._streams import (
-        create_memory_object_stream as create_memory_object_stream,
-    )
-    from ._core._subprocesses import open_process as open_process
-    from ._core._subprocesses import run_process as run_process
-    from ._core._synchronization import CapacityLimiter as CapacityLimiter
-    from ._core._synchronization import (
-        CapacityLimiterStatistics as CapacityLimiterStatistics,
-    )
-    from ._core._synchronization import Condition as Condition
-    from ._core._synchronization import ConditionStatistics as ConditionStatistics
-    from ._core._synchronization import Event as Event
-    from ._core._synchronization import EventStatistics as EventStatistics
-    from ._core._synchronization import Lock as Lock
-    from ._core._synchronization import LockStatistics as LockStatistics
-    from ._core._synchronization import ResourceGuard as ResourceGuard
-    from ._core._synchronization import Semaphore as Semaphore
-    from ._core._synchronization import SemaphoreStatistics as SemaphoreStatistics
-    from ._core._tasks import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED
-    from ._core._tasks import CancelScope as CancelScope
-    from ._core._tasks import TaskHandle as TaskHandle
-    from ._core._tasks import create_task_group as create_task_group
-    from ._core._tasks import current_effective_deadline as current_effective_deadline
-    from ._core._tasks import fail_after as fail_after
-    from ._core._tasks import fail_at as fail_at
-    from ._core._tasks import move_on_after as move_on_after
-    from ._core._tasks import move_on_at as move_on_at
-    from ._core._tempfile import NamedTemporaryFile as NamedTemporaryFile
-    from ._core._tempfile import SpooledTemporaryFile as SpooledTemporaryFile
-    from ._core._tempfile import TemporaryDirectory as TemporaryDirectory
-    from ._core._tempfile import TemporaryFile as TemporaryFile
-    from ._core._tempfile import gettempdir as gettempdir
-    from ._core._tempfile import gettempdirb as gettempdirb
-    from ._core._tempfile import mkdtemp as mkdtemp
-    from ._core._tempfile import mkstemp as mkstemp
-    from ._core._testing import TaskInfo as TaskInfo
-    from ._core._testing import get_current_task as get_current_task
-    from ._core._testing import get_running_tasks as get_running_tasks
-    from ._core._testing import wait_all_tasks_blocked as wait_all_tasks_blocked
-    from ._core._typedattr import TypedAttributeProvider as TypedAttributeProvider
-    from ._core._typedattr import TypedAttributeSet as TypedAttributeSet
-    from ._core._typedattr import typed_attribute as typed_attribute
-
-    fix_package_names()
-    set_deprecated_aliases(
-        {
-            "BrokenWorkerIntepreter": "anyio.BrokenWorkerInterpreter",
-        }
-    )

venv/lib/python3.11/site-packages/anyio/_core/_asyncio_selector_thread.py

@@ -1,167 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import socket
-import threading
-from collections.abc import Callable
-from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from _typeshed import FileDescriptorLike
-
-_selector_lock = threading.Lock()
-_selector: Selector | None = None
-
-
-class Selector:
-    def __init__(self) -> None:
-        self._thread = threading.Thread(target=self.run, name="AnyIO socket selector")
-        self._selector = DefaultSelector()
-        self._send, self._receive = socket.socketpair()
-        self._send.setblocking(False)
-        self._receive.setblocking(False)
-        # This somewhat reduces the amount of memory wasted queueing up data
-        # for wakeups. With these settings, maximum number of 1-byte sends
-        # before getting BlockingIOError:
-        #   Linux 4.8: 6
-        #   macOS (darwin 15.5): 1
-        #   Windows 10: 525347
-        # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send
-        # blocking, even on non-blocking sockets, so don't do that.)
-        self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1)
-        self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
-        # On Windows this is a TCP socket so this might matter. On other
-        # platforms this fails b/c AF_UNIX sockets aren't actually TCP.
-        try:
-            self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        except OSError:
-            pass
-
-        self._selector.register(self._receive, EVENT_READ)
-        self._closed = False
-
-    def start(self) -> None:
-        self._thread.start()
-        threading._register_atexit(self._stop)  # type: ignore[attr-defined]
-
-    def _stop(self) -> None:
-        global _selector
-        self._closed = True
-        self._notify_self()
-        self._send.close()
-        self._thread.join()
-        self._selector.unregister(self._receive)
-        self._receive.close()
-        self._selector.close()
-        _selector = None
-        assert not self._selector.get_map(), (
-            "selector still has registered file descriptors after shutdown"
-        )
-
-    def _notify_self(self) -> None:
-        try:
-            self._send.send(b"\x00")
-        except BlockingIOError:
-            pass
-
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
-        loop = asyncio.get_running_loop()
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)})
-        else:
-            if EVENT_READ in key.data:
-                raise ValueError(
-                    "this file descriptor is already registered for reading"
-                )
-
-            key.data[EVENT_READ] = loop, callback
-            self._selector.modify(fd, key.events | EVENT_READ, key.data)
-
-        self._notify_self()
-
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
-        loop = asyncio.get_running_loop()
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)})
-        else:
-            if EVENT_WRITE in key.data:
-                raise ValueError(
-                    "this file descriptor is already registered for writing"
-                )
-
-            key.data[EVENT_WRITE] = loop, callback
-            self._selector.modify(fd, key.events | EVENT_WRITE, key.data)
-
-        self._notify_self()
-
-    def remove_reader(self, fd: FileDescriptorLike) -> bool:
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-
-        if new_events := key.events ^ EVENT_READ:
-            del key.data[EVENT_READ]
-            self._selector.modify(fd, new_events, key.data)
-        else:
-            self._selector.unregister(fd)
-
-        return True
-
-    def remove_writer(self, fd: FileDescriptorLike) -> bool:
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-
-        if new_events := key.events ^ EVENT_WRITE:
-            del key.data[EVENT_WRITE]
-            self._selector.modify(fd, new_events, key.data)
-        else:
-            self._selector.unregister(fd)
-
-        return True
-
-    def run(self) -> None:
-        while not self._closed:
-            for key, events in self._selector.select():
-                if key.fileobj is self._receive:
-                    try:
-                        while self._receive.recv(4096):
-                            pass
-                    except BlockingIOError:
-                        pass
-
-                    continue
-
-                if events & EVENT_READ:
-                    loop, callback = key.data[EVENT_READ]
-                    self.remove_reader(key.fd)
-                    try:
-                        loop.call_soon_threadsafe(callback)
-                    except RuntimeError:
-                        pass  # the loop was already closed
-
-                if events & EVENT_WRITE:
-                    loop, callback = key.data[EVENT_WRITE]
-                    self.remove_writer(key.fd)
-                    try:
-                        loop.call_soon_threadsafe(callback)
-                    except RuntimeError:
-                        pass  # the loop was already closed
-
-
-def get_selector() -> Selector:
-    global _selector
-
-    with _selector_lock:
-        if _selector is None:
-            _selector = Selector()
-            _selector.start()
-
-        return _selector

venv/lib/python3.11/site-packages/anyio/_core/_concurrency_utils.py

@@ -1,156 +0,0 @@
-from __future__ import annotations
-
-from inspect import iscoroutine
-
-__all__ = ("amap", "as_completed", "gather")
-
-from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Iterable
-from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, TypeVar, overload
-
-from ..abc._tasks import get_coro_name
-from ._exceptions import BrokenResourceError
-from ._streams import create_memory_object_stream
-from ._tasks import TaskHandle, create_task_group
-
-if TYPE_CHECKING:
-    from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-
-R = TypeVar("R")
-S = TypeVar("S")
-T = TypeVar("T")
-U = TypeVar("U")
-V = TypeVar("V")
-W = TypeVar("W")
-
-
-@overload
-async def gather(
-    coro1: Coroutine[Any, Any, R], coro2: Coroutine[Any, Any, S], /
-) -> tuple[R, S]: ...
-
-
-@overload
-async def gather(
-    coro1: Coroutine[Any, Any, R],
-    coro2: Coroutine[Any, Any, S],
-    coro3: Coroutine[Any, Any, T],
-    /,
-) -> tuple[R, S, T]: ...
-
-
-@overload
-async def gather(
-    coro1: Coroutine[Any, Any, R],
-    coro2: Coroutine[Any, Any, S],
-    coro3: Coroutine[Any, Any, T],
-    coro4: Coroutine[Any, Any, U],
-    /,
-) -> tuple[R, S, T, U]: ...
-
-
-@overload
-async def gather(
-    coro1: Coroutine[Any, Any, R],
-    coro2: Coroutine[Any, Any, S],
-    coro3: Coroutine[Any, Any, T],
-    coro4: Coroutine[Any, Any, U],
-    coro5: Coroutine[Any, Any, V],
-    /,
-) -> tuple[R, S, T, U, V]: ...
-
-
-@overload
-async def gather(
-    coro1: Coroutine[Any, Any, R],
-    coro2: Coroutine[Any, Any, S],
-    coro3: Coroutine[Any, Any, T],
-    coro4: Coroutine[Any, Any, U],
-    coro5: Coroutine[Any, Any, V],
-    coro6: Coroutine[Any, Any, W],
-    /,
-) -> tuple[R, S, T, U, V, W]: ...
-
-
-# handle arbitrary length if awaitables are all of the same type
-@overload
-async def gather(*coros: Coroutine[Any, Any, R]) -> tuple[R, ...]: ...
-
-
-async def gather(*coros: Coroutine[Any, Any, Any]) -> tuple[Any, ...]:
-    """
-    Run coroutines concurrently in a task group. The order of result values corresponds
-    to the order of coroutines passed.
-
-    :param coros: coroutine objects to run as tasks
-    :return: task results for each argument in the same order as they were passed
-
-    """
-    handles: list[TaskHandle[Any]] = []
-    async with create_task_group() as tg:
-        handles.extend(tg.create_task(coro) for coro in coros)
-
-    return tuple(h.return_value for h in handles)
-
-
-@asynccontextmanager
-async def as_completed(
-    *awaitables: Awaitable[R],
-) -> AsyncGenerator[MemoryObjectReceiveStream[TaskHandle[R]]]:
-    """
-    Run awaitable objects concurrently in a task group, returning an iterator which can
-    be used to get finished task handles in the order they complete.
-
-    :param awaitables: awaitable objects to run as tasks
-    :return: MemoryObjectReceiveStream for iterating over task handles as tasks complete.
-
-    """
-    if not awaitables:
-        raise ValueError("as_completed() takes at least one awaitable")
-
-    send, recv = create_memory_object_stream[TaskHandle[R]](len(awaitables))
-    task_handles: list[TaskHandle[R]] = []
-
-    async def runner(
-        awaitable: Awaitable[R],
-        index: int,
-        _send: MemoryObjectSendStream[TaskHandle[R]],
-    ) -> R:
-        async with _send:
-            try:
-                return await awaitable
-            finally:
-                try:
-                    _send.send_nowait(task_handles[index])
-                except BrokenResourceError:
-                    pass
-
-    async with recv, create_task_group() as tg:
-        async with send:
-            for i, awaitable in enumerate(awaitables):
-                name = get_coro_name(awaitable) if iscoroutine(awaitable) else None
-                task_handles.append(
-                    tg.start_soon(runner, awaitable, i, send.clone(), name=name)
-                )
-        try:
-            yield recv
-        finally:
-            tg.cancel_scope.cancel()
-
-
-async def amap(
-    func: Callable[[T], Coroutine[Any, Any, R]], args: Iterable[T]
-) -> list[R]:
-    """
-    Run the given coroutine function concurrently for multiple argument values.
-
-    :param func: a coroutine function that takes a single argument
-    :param args: a sequence of argument values to pass to ``func``
-    :return: task results for each argument in the same order as they were passed
-
-    """
-    handles: list[TaskHandle[R]] = []
-    async with create_task_group() as tg:
-        handles.extend(tg.start_soon(func, arg) for arg in args)
-
-    return [h.return_value for h in handles]

venv/lib/python3.11/site-packages/anyio/_core/_contextmanagers.py

@@ -1,200 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
-from inspect import isasyncgen, iscoroutine, isgenerator
-from types import TracebackType
-from typing import Protocol, TypeVar, cast, final
-
-_T_co = TypeVar("_T_co", covariant=True)
-_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None")
-
-
-class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]):
-    def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ...
-
-
-class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]):
-    def __asynccontextmanager__(
-        self,
-    ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ...
-
-
-class ContextManagerMixin:
-    """
-    Mixin class providing context manager functionality via a generator-based
-    implementation.
-
-    This class allows you to implement a context manager via :meth:`__contextmanager__`
-    which should return a generator. The mechanics are meant to mirror those of
-    :func:`@contextmanager <contextlib.contextmanager>`.
-
-    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
-        that once you enter it, you can't re-enter before first exiting it.
-
-    .. seealso:: :doc:`contextmanagers`
-    """
-
-    __cm: AbstractContextManager[object, bool | None] | None = None
-
-    @final
-    def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, ContextManagerMixin)
-        if self.__cm is not None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has already been entered"
-            )
-
-        cm = self.__contextmanager__()
-        if not isinstance(cm, AbstractContextManager):
-            if isgenerator(cm):
-                raise TypeError(
-                    "__contextmanager__() returned a generator object instead of "
-                    "a context manager. Did you forget to add the @contextmanager "
-                    "decorator?"
-                )
-
-            raise TypeError(
-                f"__contextmanager__() did not return a context manager object, "
-                f"but {cm.__class__!r}"
-            )
-
-        if cm is self:
-            raise TypeError(
-                f"{self.__class__.__qualname__}.__contextmanager__() returned "
-                f"self. Did you forget to add the @contextmanager decorator and a "
-                f"'yield' statement?"
-            )
-
-        value = cm.__enter__()
-        self.__cm = cm
-        return value
-
-    @final
-    def __exit__(
-        self: _SupportsCtxMgr[object, _ExitT_co],
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> _ExitT_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, ContextManagerMixin)
-        if self.__cm is None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has not been entered yet"
-            )
-
-        # Prevent circular references
-        cm = self.__cm
-        del self.__cm
-
-        return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb))
-
-    @abstractmethod
-    def __contextmanager__(self) -> AbstractContextManager[object, bool | None]:
-        """
-        Implement your context manager logic here.
-
-        This method **must** be decorated with
-        :func:`@contextmanager <contextlib.contextmanager>`.
-
-        .. note:: Remember that the ``yield`` will raise any exception raised in the
-            enclosed context block, so use a ``finally:`` block to clean up resources!
-
-        :return: a context manager object
-        """
-
-
-class AsyncContextManagerMixin:
-    """
-    Mixin class providing async context manager functionality via a generator-based
-    implementation.
-
-    This class allows you to implement a context manager via
-    :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of
-    :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
-
-    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
-        that once you enter it, you can't re-enter before first exiting it.
-
-    .. seealso:: :doc:`contextmanagers`
-    """
-
-    __cm: AbstractAsyncContextManager[object, bool | None] | None = None
-
-    @final
-    async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co:
-        # Needed for mypy to assume self still has the __cm member
-        assert isinstance(self, AsyncContextManagerMixin)
-        if self.__cm is not None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has already been entered"
-            )
-
-        cm = self.__asynccontextmanager__()
-        if not isinstance(cm, AbstractAsyncContextManager):
-            if isasyncgen(cm):
-                raise TypeError(
-                    "__asynccontextmanager__() returned an async generator instead of "
-                    "an async context manager. Did you forget to add the "
-                    "@asynccontextmanager decorator?"
-                )
-            elif iscoroutine(cm):
-                cm.close()
-                raise TypeError(
-                    "__asynccontextmanager__() returned a coroutine object instead of "
-                    "an async context manager. Did you forget to add the "
-                    "@asynccontextmanager decorator and a 'yield' statement?"
-                )
-
-            raise TypeError(
-                f"__asynccontextmanager__() did not return an async context manager, "
-                f"but {cm.__class__!r}"
-            )
-
-        if cm is self:
-            raise TypeError(
-                f"{self.__class__.__qualname__}.__asynccontextmanager__() returned "
-                f"self. Did you forget to add the @asynccontextmanager decorator and a "
-                f"'yield' statement?"
-            )
-
-        value = await cm.__aenter__()
-        self.__cm = cm
-        return value
-
-    @final
-    async def __aexit__(
-        self: _SupportsAsyncCtxMgr[object, _ExitT_co],
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> _ExitT_co:
-        assert isinstance(self, AsyncContextManagerMixin)
-        if self.__cm is None:
-            raise RuntimeError(
-                f"this {self.__class__.__qualname__} has not been entered yet"
-            )
-
-        # Prevent circular references
-        cm = self.__cm
-        del self.__cm
-
-        return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb))
-
-    @abstractmethod
-    def __asynccontextmanager__(
-        self,
-    ) -> AbstractAsyncContextManager[object, bool | None]:
-        """
-        Implement your async context manager logic here.
-
-        This method **must** be decorated with
-        :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
-
-        .. note:: Remember that the ``yield`` will raise any exception raised in the
-            enclosed context block, so use a ``finally:`` block to clean up resources!
-
-        :return: an async context manager object
-        """

venv/lib/python3.11/site-packages/anyio/_core/_eventloop.py

@@ -1,240 +0,0 @@
-from __future__ import annotations
-
-import math
-import sys
-import threading
-from collections.abc import Awaitable, Callable, Generator
-from contextlib import contextmanager
-from contextvars import Token
-from importlib import import_module
-from typing import TYPE_CHECKING, Any, TypeVar
-
-from ._exceptions import NoEventLoopError
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-sniffio: Any
-try:
-    import sniffio
-except ModuleNotFoundError:
-    sniffio = None
-
-if TYPE_CHECKING:
-    from ..abc import AsyncBackend
-
-# This must be updated when new backends are introduced
-BACKENDS = "asyncio", "trio"
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-
-threadlocals = threading.local()
-loaded_backends: dict[str, type[AsyncBackend]] = {}
-
-
-def run(
-    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
-    *args: Unpack[PosArgsT],
-    backend: str = "asyncio",
-    backend_options: dict[str, Any] | None = None,
-) -> T_Retval:
-    """
-    Run the given coroutine function in an asynchronous event loop.
-
-    The current thread must not be already running an event loop.
-
-    :param func: a coroutine function
-    :param args: positional arguments to ``func``
-    :param backend: name of the asynchronous event loop implementation – currently
-        either ``asyncio`` or ``trio``
-    :param backend_options: keyword arguments to call the backend ``run()``
-        implementation with (documented :ref:`here <backend options>`)
-    :return: the return value of the coroutine function
-    :raises RuntimeError: if an asynchronous event loop is already running in this
-        thread
-    :raises LookupError: if the named backend is not found
-
-    """
-    if asynclib_name := current_async_library():
-        raise RuntimeError(f"Already running {asynclib_name} in this thread")
-
-    try:
-        async_backend = get_async_backend(backend)
-    except ImportError as exc:
-        if backend in BACKENDS:
-            raise LookupError(
-                f"Backend {backend!r} is not available. "
-                f"Install it with: pip install anyio[{backend}]"
-            ) from exc
-
-        raise LookupError(f"No such backend: {backend}") from exc
-
-    token = None
-    if asynclib_name is None:
-        # Since we're in control of the event loop, we can cache the name of the async
-        # library
-        token = set_current_async_library(backend)
-
-    try:
-        backend_options = backend_options or {}
-        return async_backend.run(func, args, {}, backend_options)
-    finally:
-        reset_current_async_library(token)
-
-
-async def sleep(delay: float) -> None:
-    """
-    Pause the current task for the specified duration.
-
-    :param delay: the duration, in seconds
-
-    """
-    return await get_async_backend().sleep(delay)
-
-
-async def sleep_forever() -> None:
-    """
-    Pause the current task until it's cancelled.
-
-    This is a shortcut for ``sleep(math.inf)``.
-
-    .. versionadded:: 3.1
-
-    """
-    await sleep(math.inf)
-
-
-async def sleep_until(deadline: float) -> None:
-    """
-    Pause the current task until the given time.
-
-    :param deadline: the absolute time to wake up at (according to the internal
-        monotonic clock of the event loop)
-
-    .. versionadded:: 3.1
-
-    """
-    now = current_time()
-    await sleep(max(deadline - now, 0))
-
-
-def current_time() -> float:
-    """
-    Return the current value of the event loop's internal clock.
-
-    :return: the clock value (seconds)
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().current_time()
-
-
-def get_all_backends() -> tuple[str, ...]:
-    """Return a tuple of the names of all built-in backends."""
-    return BACKENDS
-
-
-def get_available_backends() -> tuple[str, ...]:
-    """
-    Test for the availability of built-in backends.
-
-    :return a tuple of the built-in backend names that were successfully imported
-
-    .. versionadded:: 4.12
-
-    """
-    available_backends: list[str] = []
-    for backend_name in get_all_backends():
-        try:
-            get_async_backend(backend_name)
-        except ImportError:
-            continue
-
-        available_backends.append(backend_name)
-
-    return tuple(available_backends)
-
-
-def get_cancelled_exc_class() -> type[BaseException]:
-    """
-    Return the current async library's cancellation exception class.
-
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().cancelled_exception_class()
-
-
-#
-# Private API
-#
-
-
-@contextmanager
-def claim_worker_thread(
-    backend_class: type[AsyncBackend], token: object
-) -> Generator[Any, None, None]:
-    from ..lowlevel import EventLoopToken
-
-    threadlocals.current_token = EventLoopToken(backend_class, token)
-    try:
-        yield
-    finally:
-        del threadlocals.current_token
-
-
-def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]:
-    if asynclib_name is None:
-        asynclib_name = current_async_library()
-        if not asynclib_name:
-            raise NoEventLoopError(
-                f"Not currently running on any asynchronous event loop. "
-                f"Available async backends: {', '.join(get_all_backends())}"
-            )
-
-    # We use our own dict instead of sys.modules to get the already imported back-end
-    # class because the appropriate modules in sys.modules could potentially be only
-    # partially initialized
-    try:
-        return loaded_backends[asynclib_name]
-    except KeyError:
-        module = import_module(f"anyio._backends._{asynclib_name}")
-        loaded_backends[asynclib_name] = module.backend_class
-        return module.backend_class
-
-
-def current_async_library() -> str | None:
-    if sniffio is None:
-        # If sniffio is not installed, we assume we're either running asyncio or nothing
-        import asyncio
-
-        try:
-            asyncio.get_running_loop()
-            return "asyncio"
-        except RuntimeError:
-            pass
-    else:
-        try:
-            return sniffio.current_async_library()
-        except sniffio.AsyncLibraryNotFoundError:
-            pass
-
-    return None
-
-
-def set_current_async_library(asynclib_name: str | None) -> Token | None:
-    # no-op if sniffio is not installed
-    if sniffio is None:
-        return None
-
-    return sniffio.current_async_library_cvar.set(asynclib_name)
-
-
-def reset_current_async_library(token: Token | None) -> None:
-    if token is not None:
-        sniffio.current_async_library_cvar.reset(token)

venv/lib/python3.11/site-packages/anyio/_core/_exceptions.py

@@ -1,205 +0,0 @@
-from __future__ import annotations
-
-import sys
-from collections.abc import Generator
-from textwrap import dedent
-from typing import Any
-
-if sys.version_info < (3, 11):
-    from exceptiongroup import BaseExceptionGroup
-
-
-class BrokenResourceError(Exception):
-    """
-    Raised when trying to use a resource that has been rendered unusable due to external
-    causes (e.g. a send stream whose peer has disconnected).
-    """
-
-
-class BrokenWorkerProcess(Exception):
-    """
-    Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or
-    otherwise misbehaves.
-    """
-
-
-class BrokenWorkerInterpreter(Exception):
-    """
-    Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is
-    raised in the subinterpreter.
-    """
-
-    def __init__(self, excinfo: Any):
-        # This was adapted from concurrent.futures.interpreter.ExecutionFailed
-        msg = excinfo.formatted
-        if not msg:
-            if excinfo.type and excinfo.msg:
-                msg = f"{excinfo.type.__name__}: {excinfo.msg}"
-            else:
-                msg = excinfo.type.__name__ or excinfo.msg
-
-        super().__init__(msg)
-        self.excinfo = excinfo
-
-    def __str__(self) -> str:
-        try:
-            formatted = self.excinfo.errdisplay
-        except Exception:
-            return super().__str__()
-        else:
-            return dedent(
-                f"""
-                {super().__str__()}
-
-                Uncaught in the interpreter:
-
-                {formatted}
-                """.strip()
-            )
-
-
-class BusyResourceError(Exception):
-    """
-    Raised when two tasks are trying to read from or write to the same resource
-    concurrently.
-    """
-
-    def __init__(self, action: str):
-        super().__init__(f"Another task is already {action} this resource")
-
-
-class ClosedResourceError(Exception):
-    """Raised when trying to use a resource that has been closed."""
-
-
-class ConnectionFailed(OSError):
-    """
-    Raised when a connection attempt fails.
-
-    .. note:: This class inherits from :exc:`OSError` for backwards compatibility.
-    """
-
-
-def iterate_exceptions(
-    exception: BaseException,
-) -> Generator[BaseException, None, None]:
-    if isinstance(exception, BaseExceptionGroup):
-        for exc in exception.exceptions:
-            yield from iterate_exceptions(exc)
-    else:
-        yield exception
-
-
-class DelimiterNotFound(Exception):
-    """
-    Raised during
-    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
-    maximum number of bytes has been read without the delimiter being found.
-    """
-
-    def __init__(self, max_bytes: int) -> None:
-        super().__init__(
-            f"The delimiter was not found among the first {max_bytes} bytes"
-        )
-
-
-class EndOfStream(Exception):
-    """
-    Raised when trying to read from a stream that has been closed from the other end.
-    """
-
-
-class IncompleteRead(Exception):
-    """
-    Raised during
-    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
-    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
-    connection is closed before the requested amount of bytes has been read.
-    """
-
-    def __init__(self) -> None:
-        super().__init__(
-            "The stream was closed before the read operation could be completed"
-        )
-
-
-class TypedAttributeLookupError(LookupError):
-    """
-    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute
-    is not found and no default value has been given.
-    """
-
-
-class WouldBlock(Exception):
-    """Raised by ``X_nowait`` functions if ``X()`` would block."""
-
-
-class NoEventLoopError(RuntimeError):
-    """
-    Raised by several functions that require an event loop to be running in the current
-    thread when there is no running event loop.
-
-    This is also raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync`
-    if not calling from an AnyIO worker thread, and no ``token`` was passed.
-    """
-
-
-class RunFinishedError(RuntimeError):
-    """
-    Raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` if the event
-    loop associated with the explicitly passed token has already finished.
-    """
-
-    def __init__(self) -> None:
-        super().__init__(
-            "The event loop associated with the given token has already finished"
-        )
-
-
-class TaskFailed(Exception):
-    """
-    Raised when awaiting on, or attempting to access the return value of, a
-    :class:`.TaskHandle` that raised an exception.
-    """
-
-
-class TaskCancelled(TaskFailed):
-    """
-    Raised when awaiting on, or attempting to access the return value of, a
-    :class:`.TaskHandle` that was cancelled.
-    """
-
-
-class TaskNotFinished(Exception):
-    """
-    Raised when attempting to access the return value or exception of a
-    :class:`.TaskHandle` that is still pending completion.
-    """
-
-
-class FutureFailed(Exception):
-    """
-    Raised when awaiting on, or attempting to access the return value of, a
-    :class:`.Future` that raised an exception.
-    """
-
-
-class FutureCancelled(FutureFailed):
-    """
-    Raised when attempting to access the return value or exception of a
-    :class:`.Future` that was cancelled.
-    """
-
-
-class FutureNotFinished(Exception):
-    """
-    Raised when attempting to access the return value or exception of a
-    :class:`.Future` that is still pending completion.
-    """
-
-
-class FutureAlreadyFinished(Exception):
-    """
-    Raised when attempting set a result of or await a
-    :class:`.Future` that has already completed.
-    """

venv/lib/python3.11/site-packages/anyio/_core/_futures.py

@@ -1,191 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Generator
-from enum import Enum, auto
-from typing import Any, Generic, TypeVar
-
-from ._exceptions import (
-    FutureAlreadyFinished,
-    FutureCancelled,
-    FutureFailed,
-    FutureNotFinished,
-)
-from ._synchronization import Event
-
-T = TypeVar("T")
-
-
-class Future(Generic[T]):
-    """
-    An awaitable object that works similar to a :class:`asyncio.Future` but
-    with similar characteristics to a :class:`.TaskHandle`.
-    """
-
-    class Status(Enum):
-        """
-        The status of a future handle.
-
-        .. attribute:: PENDING
-
-            The future has not finished yet.
-        .. attribute:: FINISHED
-
-            The future has finished with a return value.
-        .. attribute:: CANCELLED
-
-            The future was cancelled and has finished since.
-        .. attribute:: FAILED
-
-            The future raised an exception.
-        """
-
-        PENDING = auto()
-        FINISHED = auto()
-        CANCELLED = auto()
-        FAILED = auto()
-
-    __slots__ = (
-        "_cancelled",
-        "_exception",
-        "_finished_event",
-        "_name",
-        "_return_value",
-    )
-    _return_value: T
-
-    def __init__(self, *, name: str | None = None) -> None:
-        self._finished_event = Event()
-        self._exception: BaseException | None = None
-        self._cancelled: bool = False
-        self._name = name
-
-    def _check_pending(self) -> None:
-        """Shortcut for checking if a Future is pending
-
-        :raises FutureAlreadyFinished: if future was already given a result or exception.
-        :raises FutureCancelled: if future has been cancelled previously.
-        """
-        match self.status:
-            case Future.Status.PENDING:
-                return
-            case Future.Status.FINISHED:
-                raise FutureAlreadyFinished("future has already finished")
-            case Future.Status.FAILED:
-                raise FutureAlreadyFinished("future already failed")
-            case Future.Status.CANCELLED:
-                raise FutureCancelled("future was cancelled")
-
-    async def wait(self) -> None:
-        """
-        Waits for the future to finish.
-
-        This method will attempt to wait for a result or exception
-        """
-        await self._finished_event.wait()
-
-    def cancel(self) -> None:
-        """Cancels a pending `.Future` object
-
-        Does nothing if the Future was already finished.
-        """
-        if self.status is Future.Status.PENDING:
-            self._cancelled = True
-            self._finished_event.set()
-
-    @property
-    def exception(self) -> BaseException | None:
-        """
-        The exception value of a `.Future`
-
-        :raises FutureNotFinished: if future is still pending
-        :raises FutureCancelled: if future was cancelled
-        :returns: None if future succeeds with a result sent instead
-            otherwise this will be an exception
-        """
-
-        match self.status:
-            case Future.Status.PENDING:
-                raise FutureNotFinished("the future has not finished yet")
-            case Future.Status.FINISHED:
-                return None
-            case Future.Status.CANCELLED:
-                raise FutureCancelled("the future was cancelled")
-            case Future.Status.FAILED:
-                return self._exception
-
-    @exception.setter
-    def exception(self, exception: BaseException) -> None:
-        """Send exception for a `.Future` object
-
-        :raises FutureAlreadyFinished: if future was already given a result or exception.
-        :raises FutureCancelled: if future has been cancelled previously.
-        """
-        self._check_pending()
-        self._exception = exception
-        self._finished_event.set()
-
-    @property
-    def return_value(self) -> T:
-        """
-        The return value of the future.
-
-        :raises FutureNotFinished: if the future has not finished yet
-        :raises FutureCancelled: if the future was cancelled
-        :raises FutureFailed: if the future raised an exception
-
-        """
-        match self.status:
-            case Future.Status.PENDING:
-                raise FutureNotFinished("the future has not finished yet")
-            case Future.Status.FINISHED:
-                return self._return_value
-            case Future.Status.CANCELLED:
-                raise FutureCancelled("the future was cancelled")
-            case Future.Status.FAILED:
-                raise FutureFailed(
-                    "the future raised an exception"
-                ) from self._exception
-
-    @return_value.setter
-    def return_value(self, value: T) -> None:
-        """
-        Send pending result for a `.Future` object
-
-        :raises FutureAlreadyFinished: if future was already given a result or exception.
-        :raises FutureCancelled: if future has been cancelled previously.
-        """
-        self._check_pending()
-        self._return_value = value
-        self._finished_event.set()
-
-    @property
-    def status(self) -> Future.Status:
-        """
-        The current status of a future.
-
-        Every future starts in the :attr:`~Future.Status.PENDING` state.
-        If a future is cancelled while in this state, it will transition to the
-        :attr:`Future.Status.CANCELLED` state. When the task finishes, it will
-        transition to one of the three final states (
-        :attr:`Future.Status.FINISHED`, :attr:`Future.Status.FAILED`, or
-        :attr:`Future.Status.CANCELLED`) depending on the exception the task
-        raised, if any. No other status transitions will happen.
-        """
-        if not self._finished_event.is_set():
-            return Future.Status.PENDING
-        elif self._cancelled:
-            return Future.Status.CANCELLED
-        elif self._exception is not None:
-            return Future.Status.FAILED
-        else:
-            return Future.Status.FINISHED
-
-    def __await__(self) -> Generator[Any, Any, T]:
-        yield from self.wait().__await__()
-        return self.return_value
-
-    def __repr__(self) -> str:
-        return (
-            f"<{self.__class__.__name__} {self.status.name.lower()} "
-            f"name={self._name!r}>"
-        )

venv/lib/python3.11/site-packages/anyio/_core/_resources.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from ..abc import AsyncResource  # noqa: TC001
-from ._tasks import CancelScope
-
-
-async def aclose_forcefully(resource: AsyncResource) -> None:
-    """
-    Close an asynchronous resource in a cancelled scope.
-
-    Doing this closes the resource without waiting on anything.
-
-    :param resource: the resource to close
-
-    """
-    with CancelScope() as scope:
-        scope.cancel()
-        await resource.aclose()

venv/lib/python3.11/site-packages/anyio/_core/_signals.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from contextlib import AbstractContextManager
-from signal import Signals
-
-from ._eventloop import get_async_backend
-
-
-def open_signal_receiver(
-    *signals: Signals,
-) -> AbstractContextManager[AsyncIterator[Signals]]:
-    """
-    Start receiving operating system signals.
-
-    :param signals: signals to receive (e.g. ``signal.SIGINT``)
-    :return: an asynchronous context manager for an asynchronous iterator which yields
-        signal numbers
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    .. warning:: Windows does not support signals natively so it is best to avoid
-        relying on this in cross-platform applications.
-
-    .. warning:: On asyncio, this permanently replaces any previous signal handler for
-        the given signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
-
-    """
-    return get_async_backend().open_signal_receiver(*signals)

venv/lib/python3.11/site-packages/anyio/_core/_streams.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-import math
-from typing import TypeVar
-from warnings import warn
-
-from ..streams.memory import (
-    MemoryObjectReceiveStream,
-    MemoryObjectSendStream,
-    _MemoryObjectStreamState,
-)
-
-T_Item = TypeVar("T_Item")
-
-
-class create_memory_object_stream(
-    tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]],
-):
-    """
-    Create a memory object stream.
-
-    The stream's item type can be annotated like
-    :func:`create_memory_object_stream[T_Item]`.
-
-    :param max_buffer_size: number of items held in the buffer until ``send()`` starts
-        blocking
-    :param item_type: old way of marking the streams with the right generic type for
-        static typing (does nothing on AnyIO 4)
-
-        .. deprecated:: 4.0
-          Use ``create_memory_object_stream[YourItemType](...)`` instead.
-    :return: a tuple of (send stream, receive stream)
-
-    """
-
-    def __new__(  # type: ignore[misc]
-        cls, max_buffer_size: float = 0, item_type: object = None
-    ) -> tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
-        if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
-            raise ValueError("max_buffer_size must be either an integer or math.inf")
-        if max_buffer_size < 0:
-            raise ValueError("max_buffer_size cannot be negative")
-        if item_type is not None:
-            warn(
-                "The item_type argument has been deprecated in AnyIO 4.0. "
-                "Use create_memory_object_stream[YourItemType](...) instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-        state = _MemoryObjectStreamState[T_Item](max_buffer_size)
-        return (MemoryObjectSendStream(state), MemoryObjectReceiveStream(state))

venv/lib/python3.11/site-packages/anyio/_core/_subprocesses.py

@@ -1,196 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterable, Iterable, Mapping, Sequence
-from io import BytesIO
-from os import PathLike
-from subprocess import PIPE, CalledProcessError, CompletedProcess
-from typing import IO, Any, TypeAlias, cast
-
-from ..abc import Process  # noqa: TC001
-from ._eventloop import get_async_backend
-from ._tasks import create_task_group
-
-StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
-
-
-async def run_process(
-    command: StrOrBytesPath | Sequence[StrOrBytesPath],
-    *,
-    input: bytes | None = None,
-    stdin: int | IO[Any] | None = None,
-    stdout: int | IO[Any] | None = PIPE,
-    stderr: int | IO[Any] | None = PIPE,
-    check: bool = True,
-    cwd: StrOrBytesPath | None = None,
-    env: Mapping[str, str] | None = None,
-    startupinfo: Any = None,
-    creationflags: int = 0,
-    start_new_session: bool = False,
-    pass_fds: Sequence[int] = (),
-    user: str | int | None = None,
-    group: str | int | None = None,
-    extra_groups: Iterable[str | int] | None = None,
-    umask: int = -1,
-) -> CompletedProcess[bytes]:
-    """
-    Run an external command in a subprocess and wait until it completes.
-
-    .. seealso:: :func:`subprocess.run`
-
-    :param command: either a string to pass to the shell, or an iterable of strings
-        containing the executable name or path and its arguments
-    :param input: bytes passed to the standard input of the subprocess
-    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
-        a file-like object, or `None`; ``input`` overrides this
-    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
-        a file-like object, or `None`
-    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
-        :data:`subprocess.STDOUT`, a file-like object, or `None`
-    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the
-        process terminates with a return code other than 0
-    :param cwd: If not ``None``, change the working directory to this before running the
-        command
-    :param env: if not ``None``, this mapping replaces the inherited environment
-        variables from the parent process
-    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
-        to specify process startup parameters (Windows only)
-    :param creationflags: flags that can be used to control the creation of the
-        subprocess (see :class:`subprocess.Popen` for the specifics)
-    :param start_new_session: if ``true`` the setsid() system call will be made in the
-        child process prior to the execution of the subprocess. (POSIX only)
-    :param pass_fds: sequence of file descriptors to keep open between the parent and
-        child processes. (POSIX only)
-    :param user: effective user to run the process as (Python >= 3.9, POSIX only)
-    :param group: effective group to run the process as (Python >= 3.9, POSIX only)
-    :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9,
-        POSIX only)
-    :param umask: if not negative, this umask is applied in the child process before
-        running the given command (Python >= 3.9, POSIX only)
-    :return: an object representing the completed process
-    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process
-        exits with a nonzero return code
-
-    """
-
-    async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
-        buffer = BytesIO()
-        async for chunk in stream:
-            buffer.write(chunk)
-
-        stream_contents[index] = buffer.getvalue()
-
-    if stdin is not None and input is not None:
-        raise ValueError("only one of stdin and input is allowed")
-
-    async with await open_process(
-        command,
-        stdin=PIPE if input else stdin,
-        stdout=stdout,
-        stderr=stderr,
-        cwd=cwd,
-        env=env,
-        startupinfo=startupinfo,
-        creationflags=creationflags,
-        start_new_session=start_new_session,
-        pass_fds=pass_fds,
-        user=user,
-        group=group,
-        extra_groups=extra_groups,
-        umask=umask,
-    ) as process:
-        stream_contents: list[bytes | None] = [None, None]
-        async with create_task_group() as tg:
-            if process.stdout:
-                tg.start_soon(drain_stream, process.stdout, 0)
-
-            if process.stderr:
-                tg.start_soon(drain_stream, process.stderr, 1)
-
-            if process.stdin and input:
-                await process.stdin.send(input)
-                await process.stdin.aclose()
-
-            await process.wait()
-
-    output, errors = stream_contents
-    if check and process.returncode != 0:
-        raise CalledProcessError(cast(int, process.returncode), command, output, errors)
-
-    return CompletedProcess(command, cast(int, process.returncode), output, errors)
-
-
-async def open_process(
-    command: StrOrBytesPath | Sequence[StrOrBytesPath],
-    *,
-    stdin: int | IO[Any] | None = PIPE,
-    stdout: int | IO[Any] | None = PIPE,
-    stderr: int | IO[Any] | None = PIPE,
-    cwd: StrOrBytesPath | None = None,
-    env: Mapping[str, str] | None = None,
-    startupinfo: Any = None,
-    creationflags: int = 0,
-    start_new_session: bool = False,
-    pass_fds: Sequence[int] = (),
-    user: str | int | None = None,
-    group: str | int | None = None,
-    extra_groups: Iterable[str | int] | None = None,
-    umask: int = -1,
-) -> Process:
-    """
-    Start an external command in a subprocess.
-
-    .. seealso:: :class:`subprocess.Popen`
-
-    :param command: either a string to pass to the shell, or an iterable of strings
-        containing the executable name or path and its arguments
-    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
-        file-like object, or ``None``
-    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
-        a file-like object, or ``None``
-    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
-        :data:`subprocess.STDOUT`, a file-like object, or ``None``
-    :param cwd: If not ``None``, the working directory is changed before executing
-    :param env: If env is not ``None``, it must be a mapping that defines the
-        environment variables for the new process
-    :param creationflags: flags that can be used to control the creation of the
-        subprocess (see :class:`subprocess.Popen` for the specifics)
-    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
-        to specify process startup parameters (Windows only)
-    :param start_new_session: if ``true`` the setsid() system call will be made in the
-        child process prior to the execution of the subprocess. (POSIX only)
-    :param pass_fds: sequence of file descriptors to keep open between the parent and
-        child processes. (POSIX only)
-    :param user: effective user to run the process as (POSIX only)
-    :param group: effective group to run the process as (POSIX only)
-    :param extra_groups: supplementary groups to set in the subprocess (POSIX only)
-    :param umask: if not negative, this umask is applied in the child process before
-        running the given command (POSIX only)
-    :return: an asynchronous process object
-
-    """
-    kwargs: dict[str, Any] = {}
-    if user is not None:
-        kwargs["user"] = user
-
-    if group is not None:
-        kwargs["group"] = group
-
-    if extra_groups is not None:
-        kwargs["extra_groups"] = extra_groups
-
-    if umask >= 0:
-        kwargs["umask"] = umask
-
-    return await get_async_backend().open_process(
-        command,
-        stdin=stdin,
-        stdout=stdout,
-        stderr=stderr,
-        cwd=cwd,
-        env=env,
-        startupinfo=startupinfo,
-        creationflags=creationflags,
-        start_new_session=start_new_session,
-        pass_fds=pass_fds,
-        **kwargs,
-    )

venv/lib/python3.11/site-packages/anyio/_core/_synchronization.py

@@ -1,778 +0,0 @@
-from __future__ import annotations
-
-import math
-import sys
-from collections import deque
-from collections.abc import Callable
-from dataclasses import dataclass
-from types import TracebackType
-from typing import TypeVar
-
-from ..lowlevel import checkpoint_if_cancelled
-from ._eventloop import get_async_backend
-from ._exceptions import BusyResourceError, NoEventLoopError
-from ._tasks import CancelScope
-from ._testing import TaskInfo, get_current_task
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-T = TypeVar("T")
-
-
-@dataclass(frozen=True)
-class EventStatistics:
-    """
-    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait`
-    """
-
-    tasks_waiting: int
-
-
-@dataclass(frozen=True)
-class CapacityLimiterStatistics:
-    """
-    :ivar int borrowed_tokens: number of tokens currently borrowed by tasks
-    :ivar float total_tokens: total number of available tokens
-    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from
-        this limiter
-    :ivar int tasks_waiting: number of tasks waiting on
-        :meth:`~.CapacityLimiter.acquire` or
-        :meth:`~.CapacityLimiter.acquire_on_behalf_of`
-    """
-
-    borrowed_tokens: int
-    total_tokens: float
-    borrowers: tuple[object, ...]
-    tasks_waiting: int
-
-
-@dataclass(frozen=True)
-class LockStatistics:
-    """
-    :ivar bool locked: flag indicating if this lock is locked or not
-    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the
-        lock is not held by any task)
-    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire`
-    """
-
-    locked: bool
-    owner: TaskInfo | None
-    tasks_waiting: int
-
-
-@dataclass(frozen=True)
-class ConditionStatistics:
-    """
-    :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait`
-    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying
-        :class:`~.Lock`
-    """
-
-    tasks_waiting: int
-    lock_statistics: LockStatistics
-
-
-@dataclass(frozen=True)
-class SemaphoreStatistics:
-    """
-    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire`
-
-    """
-
-    tasks_waiting: int
-
-
-class Event:
-    __slots__ = ("__weakref__",)
-
-    def __new__(cls) -> Event:
-        try:
-            return get_async_backend().create_event()
-        except NoEventLoopError:
-            return EventAdapter()
-
-    def set(self) -> None:
-        """Set the flag, notifying all listeners."""
-        raise NotImplementedError
-
-    def is_set(self) -> bool:
-        """Return ``True`` if the flag is set, ``False`` if not."""
-        raise NotImplementedError
-
-    async def wait(self) -> None:
-        """
-        Wait until the flag has been set.
-
-        If the flag has already been set when this method is called, it returns
-        immediately.
-
-        """
-        raise NotImplementedError
-
-    def statistics(self) -> EventStatistics:
-        """Return statistics about the current state of this event."""
-        raise NotImplementedError
-
-
-class EventAdapter(Event):
-    __slots__ = "_internal_event", "_is_set"
-
-    def __new__(cls) -> Self:
-        return object.__new__(cls)
-
-    def __init__(self) -> None:
-        self._internal_event: Event | None = None
-        self._is_set = False
-
-    @property
-    def _event(self) -> Event:
-        if self._internal_event is None:
-            self._internal_event = get_async_backend().create_event()
-            if self._is_set:
-                self._internal_event.set()
-
-        return self._internal_event
-
-    def set(self) -> None:
-        if self._internal_event is None:
-            self._is_set = True
-        else:
-            self._event.set()
-
-    def is_set(self) -> bool:
-        if self._internal_event is None:
-            return self._is_set
-
-        return self._internal_event.is_set()
-
-    async def wait(self) -> None:
-        await self._event.wait()
-
-    def statistics(self) -> EventStatistics:
-        if self._internal_event is None:
-            return EventStatistics(tasks_waiting=0)
-
-        return self._internal_event.statistics()
-
-
-class Lock:
-    __slots__ = ("__weakref__",)
-
-    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
-        try:
-            return get_async_backend().create_lock(fast_acquire=fast_acquire)
-        except NoEventLoopError:
-            return LockAdapter(fast_acquire=fast_acquire)
-
-    async def __aenter__(self) -> None:
-        await self.acquire()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self.release()
-
-    async def acquire(self) -> None:
-        """Acquire the lock."""
-        raise NotImplementedError
-
-    def acquire_nowait(self) -> None:
-        """
-        Acquire the lock, without blocking.
-
-        :raises ~anyio.WouldBlock: if the operation would block
-
-        """
-        raise NotImplementedError
-
-    def release(self) -> None:
-        """Release the lock."""
-        raise NotImplementedError
-
-    def locked(self) -> bool:
-        """Return True if the lock is currently held."""
-        raise NotImplementedError
-
-    def statistics(self) -> LockStatistics:
-        """
-        Return statistics about the current state of this lock.
-
-        .. versionadded:: 3.0
-        """
-        raise NotImplementedError
-
-
-class LockAdapter(Lock):
-    __slots__ = "_fast_acquire", "_internal_lock"
-
-    def __new__(cls, *, fast_acquire: bool = False) -> Self:
-        return object.__new__(cls)
-
-    def __init__(self, *, fast_acquire: bool = False):
-        self._internal_lock: Lock | None = None
-        self._fast_acquire = fast_acquire
-
-    @property
-    def _lock(self) -> Lock:
-        if self._internal_lock is None:
-            self._internal_lock = get_async_backend().create_lock(
-                fast_acquire=self._fast_acquire
-            )
-
-        return self._internal_lock
-
-    async def __aenter__(self) -> None:
-        await self._lock.acquire()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        if self._internal_lock is not None:
-            self._internal_lock.release()
-
-    async def acquire(self) -> None:
-        """Acquire the lock."""
-        await self._lock.acquire()
-
-    def acquire_nowait(self) -> None:
-        """
-        Acquire the lock, without blocking.
-
-        :raises ~anyio.WouldBlock: if the operation would block
-
-        """
-        self._lock.acquire_nowait()
-
-    def release(self) -> None:
-        """Release the lock."""
-        self._lock.release()
-
-    def locked(self) -> bool:
-        """Return True if the lock is currently held."""
-        return self._lock.locked()
-
-    def statistics(self) -> LockStatistics:
-        """
-        Return statistics about the current state of this lock.
-
-        .. versionadded:: 3.0
-
-        """
-        if self._internal_lock is None:
-            return LockStatistics(False, None, 0)
-
-        return self._internal_lock.statistics()
-
-
-class Condition:
-    __slots__ = "__weakref__", "_lock", "_owner_task", "_waiters"
-
-    def __init__(self, lock: Lock | None = None):
-        self._owner_task: TaskInfo | None = None
-        self._lock = lock or Lock()
-        self._waiters: deque[Event] = deque()
-
-    async def __aenter__(self) -> None:
-        await self.acquire()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self.release()
-
-    def _check_acquired(self) -> None:
-        if self._owner_task != get_current_task():
-            raise RuntimeError("The current task is not holding the underlying lock")
-
-    async def acquire(self) -> None:
-        """Acquire the underlying lock."""
-        await self._lock.acquire()
-        self._owner_task = get_current_task()
-
-    def acquire_nowait(self) -> None:
-        """
-        Acquire the underlying lock, without blocking.
-
-        :raises ~anyio.WouldBlock: if the operation would block
-
-        """
-        self._lock.acquire_nowait()
-        self._owner_task = get_current_task()
-
-    def release(self) -> None:
-        """Release the underlying lock."""
-        self._lock.release()
-
-    def locked(self) -> bool:
-        """Return True if the lock is set."""
-        return self._lock.locked()
-
-    def notify(self, n: int = 1) -> None:
-        """Notify exactly n listeners."""
-        self._check_acquired()
-        for _ in range(n):
-            try:
-                event = self._waiters.popleft()
-            except IndexError:
-                break
-
-            event.set()
-
-    def notify_all(self) -> None:
-        """Notify all the listeners."""
-        self._check_acquired()
-        for event in self._waiters:
-            event.set()
-
-        self._waiters.clear()
-
-    async def wait(self) -> None:
-        """Wait for a notification."""
-        await checkpoint_if_cancelled()
-        self._check_acquired()
-        event = Event()
-        self._waiters.append(event)
-        self.release()
-        try:
-            await event.wait()
-        except BaseException:
-            if not event.is_set():
-                self._waiters.remove(event)
-            elif self._waiters:
-                # This task was notified by could not act on it, so pass
-                # it on to the next task
-                self._waiters.popleft().set()
-
-            raise
-        finally:
-            with CancelScope(shield=True):
-                await self.acquire()
-
-    async def wait_for(self, predicate: Callable[[], T]) -> T:
-        """
-        Wait until a predicate becomes true.
-
-        :param predicate: a callable that returns a truthy value when the condition is
-            met
-        :return: the result of the predicate
-
-        .. versionadded:: 4.11.0
-
-        """
-        while not (result := predicate()):
-            await self.wait()
-
-        return result
-
-    def statistics(self) -> ConditionStatistics:
-        """
-        Return statistics about the current state of this condition.
-
-        .. versionadded:: 3.0
-        """
-        return ConditionStatistics(len(self._waiters), self._lock.statistics())
-
-
-class Semaphore:
-    __slots__ = "__weakref__", "_fast_acquire"
-
-    def __new__(
-        cls,
-        initial_value: int,
-        *,
-        max_value: int | None = None,
-        fast_acquire: bool = False,
-    ) -> Semaphore:
-        try:
-            return get_async_backend().create_semaphore(
-                initial_value, max_value=max_value, fast_acquire=fast_acquire
-            )
-        except NoEventLoopError:
-            return SemaphoreAdapter(initial_value, max_value=max_value)
-
-    def __init__(
-        self,
-        initial_value: int,
-        *,
-        max_value: int | None = None,
-        fast_acquire: bool = False,
-    ):
-        if not isinstance(initial_value, int):
-            raise TypeError("initial_value must be an integer")
-        if initial_value < 0:
-            raise ValueError("initial_value must be >= 0")
-        if max_value is not None:
-            if not isinstance(max_value, int):
-                raise TypeError("max_value must be an integer or None")
-            if max_value < initial_value:
-                raise ValueError(
-                    "max_value must be equal to or higher than initial_value"
-                )
-
-        self._fast_acquire = fast_acquire
-
-    async def __aenter__(self) -> Self:
-        await self.acquire()
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self.release()
-
-    async def acquire(self) -> None:
-        """Decrement the semaphore value, blocking if necessary."""
-        raise NotImplementedError
-
-    def acquire_nowait(self) -> None:
-        """
-        Acquire the underlying lock, without blocking.
-
-        :raises ~anyio.WouldBlock: if the operation would block
-
-        """
-        raise NotImplementedError
-
-    def release(self) -> None:
-        """Increment the semaphore value."""
-        raise NotImplementedError
-
-    @property
-    def value(self) -> int:
-        """The current value of the semaphore."""
-        raise NotImplementedError
-
-    @property
-    def max_value(self) -> int | None:
-        """The maximum value of the semaphore."""
-        raise NotImplementedError
-
-    def statistics(self) -> SemaphoreStatistics:
-        """
-        Return statistics about the current state of this semaphore.
-
-        .. versionadded:: 3.0
-        """
-        raise NotImplementedError
-
-
-class SemaphoreAdapter(Semaphore):
-    __slots__ = "_initial_value", "_internal_semaphore", "_max_value"
-
-    def __new__(
-        cls,
-        initial_value: int,
-        *,
-        max_value: int | None = None,
-        fast_acquire: bool = False,
-    ) -> Self:
-        return object.__new__(cls)
-
-    def __init__(
-        self,
-        initial_value: int,
-        *,
-        max_value: int | None = None,
-        fast_acquire: bool = False,
-    ) -> None:
-        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
-        self._internal_semaphore: Semaphore | None = None
-        self._initial_value = initial_value
-        self._max_value = max_value
-
-    @property
-    def _semaphore(self) -> Semaphore:
-        if self._internal_semaphore is None:
-            self._internal_semaphore = get_async_backend().create_semaphore(
-                self._initial_value, max_value=self._max_value
-            )
-
-        return self._internal_semaphore
-
-    async def acquire(self) -> None:
-        await self._semaphore.acquire()
-
-    def acquire_nowait(self) -> None:
-        self._semaphore.acquire_nowait()
-
-    def release(self) -> None:
-        self._semaphore.release()
-
-    @property
-    def value(self) -> int:
-        if self._internal_semaphore is None:
-            return self._initial_value
-
-        return self._semaphore.value
-
-    @property
-    def max_value(self) -> int | None:
-        return self._max_value
-
-    def statistics(self) -> SemaphoreStatistics:
-        if self._internal_semaphore is None:
-            return SemaphoreStatistics(tasks_waiting=0)
-
-        return self._semaphore.statistics()
-
-
-class CapacityLimiter:
-    __slots__ = ("__weakref__",)
-
-    def __new__(cls, total_tokens: float) -> CapacityLimiter:
-        try:
-            return get_async_backend().create_capacity_limiter(total_tokens)
-        except NoEventLoopError:
-            return CapacityLimiterAdapter(total_tokens)
-
-    async def __aenter__(self) -> None:
-        raise NotImplementedError
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        raise NotImplementedError
-
-    @property
-    def total_tokens(self) -> float:
-        """
-        The total number of tokens available for borrowing.
-
-        This is a read-write property. If the total number of tokens is increased, the
-        proportionate number of tasks waiting on this limiter will be granted their
-        tokens.
-
-        .. versionchanged:: 3.0
-            The property is now writable.
-        .. versionchanged:: 4.12
-            The value can now be set to 0.
-
-        """
-        raise NotImplementedError
-
-    @total_tokens.setter
-    def total_tokens(self, value: float) -> None:
-        raise NotImplementedError
-
-    @property
-    def borrowed_tokens(self) -> int:
-        """The number of tokens that have currently been borrowed."""
-        raise NotImplementedError
-
-    @property
-    def available_tokens(self) -> float:
-        """The number of tokens currently available to be borrowed"""
-        raise NotImplementedError
-
-    def acquire_nowait(self) -> None:
-        """
-        Acquire a token for the current task without waiting for one to become
-        available.
-
-        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
-
-        """
-        raise NotImplementedError
-
-    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
-        """
-        Acquire a token without waiting for one to become available.
-
-        :param borrower: the entity borrowing a token
-        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
-
-        """
-        raise NotImplementedError
-
-    async def acquire(self) -> None:
-        """
-        Acquire a token for the current task, waiting if necessary for one to become
-        available.
-
-        """
-        raise NotImplementedError
-
-    async def acquire_on_behalf_of(self, borrower: object) -> None:
-        """
-        Acquire a token, waiting if necessary for one to become available.
-
-        :param borrower: the entity borrowing a token
-
-        """
-        raise NotImplementedError
-
-    def release(self) -> None:
-        """
-        Release the token held by the current task.
-
-        :raises RuntimeError: if the current task has not borrowed a token from this
-            limiter.
-
-        """
-        raise NotImplementedError
-
-    def release_on_behalf_of(self, borrower: object) -> None:
-        """
-        Release the token held by the given borrower.
-
-        :raises RuntimeError: if the borrower has not borrowed a token from this
-            limiter.
-
-        """
-        raise NotImplementedError
-
-    def statistics(self) -> CapacityLimiterStatistics:
-        """
-        Return statistics about the current state of this limiter.
-
-        .. versionadded:: 3.0
-
-        """
-        raise NotImplementedError
-
-
-class CapacityLimiterAdapter(CapacityLimiter):
-    __slots__ = "_internal_limiter", "_total_tokens"
-
-    def __new__(cls, total_tokens: float) -> Self:
-        return object.__new__(cls)
-
-    def __init__(self, total_tokens: float) -> None:
-        self._internal_limiter: CapacityLimiter | None = None
-        self.total_tokens = total_tokens
-
-    @property
-    def _limiter(self) -> CapacityLimiter:
-        if self._internal_limiter is None:
-            self._internal_limiter = get_async_backend().create_capacity_limiter(
-                self._total_tokens
-            )
-
-        return self._internal_limiter
-
-    async def __aenter__(self) -> None:
-        await self._limiter.__aenter__()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        return await self._limiter.__aexit__(exc_type, exc_val, exc_tb)
-
-    @property
-    def total_tokens(self) -> float:
-        if self._internal_limiter is None:
-            return self._total_tokens
-
-        return self._internal_limiter.total_tokens
-
-    @total_tokens.setter
-    def total_tokens(self, value: float) -> None:
-        if not isinstance(value, int) and not math.isinf(value):
-            raise TypeError("total_tokens must be an int or math.inf")
-        elif value < 0:
-            raise ValueError("total_tokens must be >= 0")
-
-        if self._internal_limiter is None:
-            self._total_tokens = value
-            return
-
-        self._limiter.total_tokens = value
-
-    @property
-    def borrowed_tokens(self) -> int:
-        if self._internal_limiter is None:
-            return 0
-
-        return self._internal_limiter.borrowed_tokens
-
-    @property
-    def available_tokens(self) -> float:
-        if self._internal_limiter is None:
-            return self._total_tokens
-
-        return self._internal_limiter.available_tokens
-
-    def acquire_nowait(self) -> None:
-        self._limiter.acquire_nowait()
-
-    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
-        self._limiter.acquire_on_behalf_of_nowait(borrower)
-
-    async def acquire(self) -> None:
-        await self._limiter.acquire()
-
-    async def acquire_on_behalf_of(self, borrower: object) -> None:
-        await self._limiter.acquire_on_behalf_of(borrower)
-
-    def release(self) -> None:
-        self._limiter.release()
-
-    def release_on_behalf_of(self, borrower: object) -> None:
-        self._limiter.release_on_behalf_of(borrower)
-
-    def statistics(self) -> CapacityLimiterStatistics:
-        if self._internal_limiter is None:
-            return CapacityLimiterStatistics(
-                borrowed_tokens=0,
-                total_tokens=self.total_tokens,
-                borrowers=(),
-                tasks_waiting=0,
-            )
-
-        return self._internal_limiter.statistics()
-
-
-class ResourceGuard:
-    """
-    A context manager for ensuring that a resource is only used by a single task at a
-    time.
-
-    Entering this context manager while the previous has not exited it yet will trigger
-    :exc:`BusyResourceError`.
-
-    :param action: the action to guard against (visible in the :exc:`BusyResourceError`
-        when triggered, e.g. "Another task is already {action} this resource")
-
-    .. versionadded:: 4.1
-    """
-
-    __slots__ = "__weakref__", "_guarded", "action"
-
-    def __init__(self, action: str = "using"):
-        self.action: str = action
-        self._guarded = False
-
-    def __enter__(self) -> None:
-        if self._guarded:
-            raise BusyResourceError(self.action)
-
-        self._guarded = True
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        self._guarded = False

venv/lib/python3.11/site-packages/anyio/_core/_tasks.py

@@ -1,464 +0,0 @@
-from __future__ import annotations
-
-import math
-import sys
-from collections.abc import (
-    Coroutine,
-    Generator,
-)
-from contextlib import contextmanager
-from enum import Enum, auto
-from inspect import iscoroutine
-from types import TracebackType
-from typing import Any, Generic, final
-
-from ..abc import TaskGroup, TaskStatus
-from ._eventloop import get_async_backend, get_cancelled_exc_class
-from ._exceptions import TaskCancelled, TaskFailed, TaskNotFinished
-
-if sys.version_info >= (3, 13):
-    from typing import TypeVar
-else:
-    from typing_extensions import TypeVar
-
-if sys.version_info >= (3, 11):
-    from typing import Never, Self, TypeVarTuple
-else:
-    from typing_extensions import Never, Self, TypeVarTuple
-
-T = TypeVar("T")
-T_co = TypeVar("T_co", covariant=True)
-T_startval_co = TypeVar("T_startval_co", covariant=True, default=Never)
-PosArgsT = TypeVarTuple("PosArgsT")
-
-
-class _IgnoredTaskStatus(TaskStatus[object]):
-    def started(self, value: object = None) -> None:
-        pass
-
-
-TASK_STATUS_IGNORED = _IgnoredTaskStatus()
-
-
-class CancelScope:
-    """
-    Wraps a unit of work that can be made separately cancellable.
-
-    :param deadline: The time (clock value) when this scope is cancelled automatically
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-    """
-
-    __slots__ = ("__weakref__",)
-
-    def __new__(
-        cls, *, deadline: float = math.inf, shield: bool = False
-    ) -> CancelScope:
-        return get_async_backend().create_cancel_scope(shield=shield, deadline=deadline)
-
-    def cancel(self, reason: str | None = None) -> None:
-        """
-        Cancel this scope immediately.
-
-        :param reason: a message describing the reason for the cancellation
-
-        """
-        raise NotImplementedError
-
-    @property
-    def deadline(self) -> float:
-        """
-        The time (clock value) when this scope is cancelled automatically.
-
-        Will be ``float('inf')`` if no timeout has been set.
-
-        """
-        raise NotImplementedError
-
-    @deadline.setter
-    def deadline(self, value: float) -> None:
-        raise NotImplementedError
-
-    @property
-    def cancel_called(self) -> bool:
-        """``True`` if :meth:`cancel` has been called."""
-        raise NotImplementedError
-
-    @property
-    def cancelled_caught(self) -> bool:
-        """
-        ``True`` if this scope suppressed a cancellation exception it itself raised.
-
-        This is typically used to check if any work was interrupted, or to see if the
-        scope was cancelled due to its deadline being reached. The value will, however,
-        only be ``True`` if the cancellation was triggered by the scope itself (and not
-        an outer scope).
-
-        """
-        raise NotImplementedError
-
-    @property
-    def shield(self) -> bool:
-        """
-        ``True`` if this scope is shielded from external cancellation.
-
-        While a scope is shielded, it will not receive cancellations from outside.
-
-        """
-        raise NotImplementedError
-
-    @shield.setter
-    def shield(self, value: bool) -> None:
-        raise NotImplementedError
-
-    def __enter__(self) -> Self:
-        raise NotImplementedError
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> bool:
-        raise NotImplementedError
-
-
-@contextmanager
-def fail_at(
-    deadline: float | None, shield: bool = False, reason: str | None = None
-) -> Generator[CancelScope, None, None]:
-    """
-    Create a context manager which raises a :class:`TimeoutError` if the code in the
-    enclosing context does not finish by the given deadline.
-
-    :param deadline: the deadline before raising the exception, or
-        ``None`` to disable the timeout
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :param reason: explanation for timeout to add to the message of a raised `TimeoutError`
-    :return: a context manager that yields a cancel scope
-    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\]
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    .. versionadded:: 4.15.0
-
-    """
-    current_time = get_async_backend().current_time
-    effective_deadline = math.inf if deadline is None else deadline
-    with get_async_backend().create_cancel_scope(
-        deadline=effective_deadline, shield=shield
-    ) as cancel_scope:
-        yield cancel_scope
-
-    if cancel_scope.cancelled_caught and current_time() >= cancel_scope.deadline:
-        raise TimeoutError(reason) if reason else TimeoutError
-
-
-@contextmanager
-def fail_after(
-    delay: float | None, shield: bool = False, reason: str | None = None
-) -> Generator[CancelScope, None, None]:
-    """
-    Create a context manager which raises a :class:`TimeoutError` if the code in the
-    enclosing context block does not finish in time.
-
-    :param delay: maximum allowed time (in seconds) before raising the exception, or
-        ``None`` to disable the timeout
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :param reason: explanation for timeout to add to the message of a raised `TimeoutError`
-    :return: a context manager that yields a cancel scope
-    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\]
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    current_time = get_async_backend().current_time
-    deadline = (current_time() + delay) if delay is not None else math.inf
-    with fail_at(deadline, shield=shield, reason=reason) as scope:
-        yield scope
-
-
-def move_on_at(deadline: float | None, shield: bool = False) -> CancelScope:
-    """
-    Create a cancel scope with a deadline that expires after the given delay.
-
-    :param deadline: the deadline before exiting the context block, or
-        ``None`` to disable the timeout
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :return: a cancel scope
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    .. versionadded:: 4.15.0
-
-    """
-    return get_async_backend().create_cancel_scope(
-        deadline=deadline if deadline is not None else math.inf, shield=shield
-    )
-
-
-def move_on_after(delay: float | None, shield: bool = False) -> CancelScope:
-    """
-    Create a cancel scope with a deadline that expires after the given delay.
-
-    :param delay: maximum allowed time (in seconds) before exiting the context block, or
-        ``None`` to disable the timeout
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :return: a cancel scope
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    .. note:: Unlike with :func:`fail_after`, the timer starts when this function is
-        called, not when the context manager is entered. This will be changed in v5.0.
-
-    """
-    deadline = (
-        (get_async_backend().current_time() + delay) if delay is not None else math.inf
-    )
-    return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield)
-
-
-def current_effective_deadline() -> float:
-    """
-    Return the nearest deadline among all the cancel scopes effective for the current
-    task.
-
-    :return: a clock value from the event loop's internal clock (or ``float('inf')`` if
-        there is no deadline in effect, or ``float('-inf')`` if the current scope has
-        been cancelled)
-    :rtype: float
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().current_effective_deadline()
-
-
-def create_task_group() -> TaskGroup:
-    """
-    Create a task group.
-
-    :return: a task group
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().create_task_group()
-
-
-@final
-class TaskHandle(Generic[T_co, T_startval_co]):
-    """
-    Returned from the task-spawning methods of :class:`TaskGroup`. Can be awaited on to
-    get the return value of the task (or the raised exception). If the task was
-    terminated by a :exc:`BaseException`, :exc:`TaskFailed` will be raised (or its
-    subclass :exc:`TaskCancelled` if the task was cancelled).
-
-    .. versionadded:: 4.14.0
-    """
-
-    class Status(Enum):
-        """
-        The status of a task handle.
-
-        .. attribute:: PENDING
-
-            The task has not finished yet.
-        .. attribute:: FINISHED
-
-            The task has finished with a return value.
-        .. attribute:: CANCELLING
-
-            The task has been cancelled but has not finished yet.
-        .. attribute:: CANCELLED
-
-            The task was cancelled and has finished since.
-        .. attribute:: FAILED
-
-            The task raised an exception.
-        """
-
-        PENDING = auto()
-        FINISHED = auto()
-        CANCELLING = auto()
-        CANCELLED = auto()
-        FAILED = auto()
-
-    __slots__ = (
-        "__weakref__",
-        "_cancel_scope",
-        "_coro",
-        "_exception",
-        "_finished_event",
-        "_name",
-        "_return_value",
-        "_start_value",
-    )
-
-    _return_value: T_co
-    _start_value: T_startval_co
-
-    def __init__(
-        self,
-        coro: Coroutine[Any, Any, T_co],
-        name: object,
-        cancel_scope: CancelScope | None = None,
-    ) -> None:
-        from ._synchronization import Event
-
-        self._coro = coro
-        self._cancel_scope = cancel_scope if cancel_scope is not None else CancelScope()
-        self._finished_event = Event()
-        self._exception: BaseException | None = None
-
-        if name is not None:
-            self._name = str(name)
-        elif iscoroutine(coro):
-            self._name = coro.__qualname__
-        else:
-            self._name = str(coro)  # coroutine-like object (e.g. asend() objects)
-
-    async def _run_coro(self) -> None:
-        __tracebackhide__ = True
-
-        with self._cancel_scope:
-            try:
-                retval = await self._coro
-            except BaseException as exc:
-                self._exception = exc
-                raise
-            else:
-                self._return_value = retval
-            finally:
-                self._finished_event.set()
-                del self  # Break the reference cycle
-
-    def cancel(self) -> None:
-        """
-        Set the task to a cancelled state.
-
-        This will interrupt any interruptible asynchronous operation, and will cause
-        any further awaits on this task to get immediately cancelled, unless done in
-        a shielded cancel scope.
-
-        If the task has already finished, this method has no effect.
-        """
-        if not self._finished_event.is_set():
-            self._cancel_scope.cancel()
-
-    @property
-    def coro(self) -> Coroutine[Any, Any, T_co]:
-        """
-        The coroutine object that was passed to one of the task-spawning methods in
-        :class:`TaskGroup`.
-        """
-        return self._coro
-
-    @property
-    def status(self) -> TaskHandle.Status:
-        """
-        The current status of the task.
-
-        Every task starts in the :attr:`~TaskHandle.Status.PENDING` state.
-        If a task is cancelled while in this state, it will transition to the
-        :attr:`~TaskHandle.Status.CANCELLING` state. When the task finishes, it will
-        transition to one of the three final states (
-        :attr:`~TaskHandle.Status.FINISHED`, :attr:`~TaskHandle.Status.FAILED`, or
-        :attr:`~TaskHandle.Status.CANCELLING`) depending on the exception the task
-        raised, if any. No other status transitions will happen.
-        """
-        if not self._finished_event.is_set():
-            if self._cancel_scope.cancel_called:
-                return TaskHandle.Status.CANCELLING
-            else:
-                return TaskHandle.Status.PENDING
-        elif self._exception is not None:
-            if isinstance(self._exception, get_cancelled_exc_class()):
-                return TaskHandle.Status.CANCELLED
-            else:
-                return TaskHandle.Status.FAILED
-        else:
-            return TaskHandle.Status.FINISHED
-
-    @property
-    def name(self) -> str:
-        """The name of the task."""
-        return self._name
-
-    @property
-    def exception(self) -> BaseException | None:
-        """
-        The exception raised by the task, or ``None`` if it finished without raising.
-
-        :raises TaskNotFinished: if the task has not finished yet
-        :raises TaskCancelled: if the task was cancelled
-
-        """
-        match self.status:
-            case TaskHandle.Status.PENDING:
-                raise TaskNotFinished("the task has not finished yet")
-            case TaskHandle.Status.FINISHED:
-                return None
-            case TaskHandle.Status.CANCELLING:
-                raise TaskCancelled("the task was cancelled")
-            case TaskHandle.Status.CANCELLED:
-                raise TaskCancelled("the task was cancelled") from self._exception
-            case TaskHandle.Status.FAILED:
-                return self._exception
-
-    @property
-    def return_value(self) -> T_co:
-        """
-        The return value of the task.
-
-        :raises TaskNotFinished: if the task has not finished yet
-        :raises TaskCancelled: if the task was cancelled
-        :raises TaskFailed: if the task raised an exception
-
-        """
-        match self.status:
-            case TaskHandle.Status.PENDING:
-                raise TaskNotFinished("the task has not finished yet")
-            case TaskHandle.Status.FINISHED:
-                return self._return_value
-            case TaskHandle.Status.CANCELLING:
-                raise TaskCancelled("the task was cancelled")
-            case TaskHandle.Status.CANCELLED:
-                raise TaskCancelled("the task was cancelled") from self._exception
-            case TaskHandle.Status.FAILED:
-                raise TaskFailed("the task raised an exception") from self._exception
-
-    @property
-    def start_value(self) -> T_startval_co:
-        """
-        The value passed to :meth:`task_status.started() <.abc.TaskStatus.started>`,
-
-        :raises RuntimeError: if the task was not started with :meth:`TaskGroup.start()
-            <.abc.TaskGroup.start>`
-        """
-        try:
-            return self._start_value
-        except AttributeError:
-            raise RuntimeError(
-                "the task was not started with TaskGroup.start()"
-            ) from None
-
-    async def wait(self) -> None:
-        """
-        Wait for the task to finish.
-
-        This method will return as soon as the task has finished, no matter how it
-        happened.
-        """
-        await self._finished_event.wait()
-
-    def __await__(self) -> Generator[Any, Any, T_co]:
-        yield from self._finished_event.wait().__await__()
-        return self.return_value
-
-    def __repr__(self) -> str:
-        return (
-            f"<{self.__class__.__name__} {self.status.name.lower()} "
-            f"name={self._name!r} coro={self._coro!r}>"
-        )

venv/lib/python3.11/site-packages/anyio/_core/_tempfile.py

@@ -1,615 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-import tempfile
-from collections.abc import Iterable
-from io import BytesIO, TextIOWrapper
-from types import TracebackType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AnyStr,
-    Generic,
-    overload,
-)
-
-from .. import to_thread
-from .._core._fileio import AsyncFile
-from ..lowlevel import checkpoint_if_cancelled
-from ._tasks import CancelScope
-
-if TYPE_CHECKING:
-    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
-
-
-class TemporaryFile(Generic[AnyStr]):
-    """
-    An asynchronous temporary file that is automatically created and cleaned up.
-
-    This class provides an asynchronous context manager interface to a temporary file.
-    The file is created using Python's standard `tempfile.TemporaryFile` function in a
-    background thread, and is wrapped as an asynchronous file using `AsyncFile`.
-
-    :param mode: The mode in which the file is opened. Defaults to "w+b".
-    :param buffering: The buffering policy (-1 means the default buffering).
-    :param encoding: The encoding used to decode or encode the file. Only applicable in
-        text mode.
-    :param newline: Controls how universal newlines mode works (only applicable in text
-        mode).
-    :param suffix: The suffix for the temporary file name.
-    :param prefix: The prefix for the temporary file name.
-    :param dir: The directory in which the temporary file is created.
-    :param errors: The error handling scheme used for encoding/decoding errors.
-    """
-
-    _async_file: AsyncFile[AnyStr]
-
-    @overload
-    def __init__(
-        self: TemporaryFile[bytes],
-        mode: OpenBinaryMode = ...,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        *,
-        errors: str | None = ...,
-    ): ...
-    @overload
-    def __init__(
-        self: TemporaryFile[str],
-        mode: OpenTextMode,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        *,
-        errors: str | None = ...,
-    ): ...
-
-    def __init__(
-        self,
-        mode: OpenTextMode | OpenBinaryMode = "w+b",
-        buffering: int = -1,
-        encoding: str | None = None,
-        newline: str | None = None,
-        suffix: str | None = None,
-        prefix: str | None = None,
-        dir: str | None = None,
-        *,
-        errors: str | None = None,
-    ) -> None:
-        self.mode = mode
-        self.buffering = buffering
-        self.encoding = encoding
-        self.newline = newline
-        self.suffix: str | None = suffix
-        self.prefix: str | None = prefix
-        self.dir: str | None = dir
-        self.errors = errors
-
-    async def __aenter__(self) -> AsyncFile[AnyStr]:
-        fp = await to_thread.run_sync(
-            lambda: tempfile.TemporaryFile(
-                self.mode,
-                self.buffering,
-                self.encoding,
-                self.newline,
-                self.suffix,
-                self.prefix,
-                self.dir,
-                errors=self.errors,
-            )
-        )
-        self._async_file = AsyncFile(fp)
-        return self._async_file
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        await self._async_file.aclose()
-
-
-class NamedTemporaryFile(Generic[AnyStr]):
-    """
-    An asynchronous named temporary file that is automatically created and cleaned up.
-
-    This class provides an asynchronous context manager for a temporary file with a
-    visible name in the file system. It uses Python's standard
-    :func:`~tempfile.NamedTemporaryFile` function and wraps the file object with
-    :class:`AsyncFile` for asynchronous operations.
-
-    :param mode: The mode in which the file is opened. Defaults to "w+b".
-    :param buffering: The buffering policy (-1 means the default buffering).
-    :param encoding: The encoding used to decode or encode the file. Only applicable in
-        text mode.
-    :param newline: Controls how universal newlines mode works (only applicable in text
-        mode).
-    :param suffix: The suffix for the temporary file name.
-    :param prefix: The prefix for the temporary file name.
-    :param dir: The directory in which the temporary file is created.
-    :param delete: Whether to delete the file when it is closed.
-    :param errors: The error handling scheme used for encoding/decoding errors.
-    :param delete_on_close: (Python 3.12+) Whether to delete the file on close.
-    """
-
-    _async_file: AsyncFile[AnyStr]
-
-    @overload
-    def __init__(
-        self: NamedTemporaryFile[bytes],
-        mode: OpenBinaryMode = ...,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        delete: bool = ...,
-        *,
-        errors: str | None = ...,
-        delete_on_close: bool = ...,
-    ): ...
-    @overload
-    def __init__(
-        self: NamedTemporaryFile[str],
-        mode: OpenTextMode,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        delete: bool = ...,
-        *,
-        errors: str | None = ...,
-        delete_on_close: bool = ...,
-    ): ...
-
-    def __init__(
-        self,
-        mode: OpenBinaryMode | OpenTextMode = "w+b",
-        buffering: int = -1,
-        encoding: str | None = None,
-        newline: str | None = None,
-        suffix: str | None = None,
-        prefix: str | None = None,
-        dir: str | None = None,
-        delete: bool = True,
-        *,
-        errors: str | None = None,
-        delete_on_close: bool = True,
-    ) -> None:
-        self._params: dict[str, Any] = {
-            "mode": mode,
-            "buffering": buffering,
-            "encoding": encoding,
-            "newline": newline,
-            "suffix": suffix,
-            "prefix": prefix,
-            "dir": dir,
-            "delete": delete,
-            "errors": errors,
-        }
-        if sys.version_info >= (3, 12):
-            self._params["delete_on_close"] = delete_on_close
-
-    async def __aenter__(self) -> AsyncFile[AnyStr]:
-        fp = await to_thread.run_sync(
-            lambda: tempfile.NamedTemporaryFile(**self._params)
-        )
-        self._async_file = AsyncFile(fp)
-        return self._async_file
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        await self._async_file.aclose()
-
-
-class SpooledTemporaryFile(AsyncFile[AnyStr]):
-    """
-    An asynchronous spooled temporary file that starts in memory and is spooled to disk.
-
-    This class provides an asynchronous interface to a spooled temporary file, much like
-    Python's standard :class:`~tempfile.SpooledTemporaryFile`. It supports asynchronous
-    write operations and provides a method to force a rollover to disk.
-
-    :param max_size: Maximum size in bytes before the file is rolled over to disk.
-    :param mode: The mode in which the file is opened. Defaults to "w+b".
-    :param buffering: The buffering policy (-1 means the default buffering).
-    :param encoding: The encoding used to decode or encode the file (text mode only).
-    :param newline: Controls how universal newlines mode works (text mode only).
-    :param suffix: The suffix for the temporary file name.
-    :param prefix: The prefix for the temporary file name.
-    :param dir: The directory in which the temporary file is created.
-    :param errors: The error handling scheme used for encoding/decoding errors.
-    """
-
-    _rolled: bool = False
-
-    @overload
-    def __init__(
-        self: SpooledTemporaryFile[bytes],
-        max_size: int = ...,
-        mode: OpenBinaryMode = ...,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        *,
-        errors: str | None = ...,
-    ): ...
-    @overload
-    def __init__(
-        self: SpooledTemporaryFile[str],
-        max_size: int = ...,
-        mode: OpenTextMode = ...,
-        buffering: int = ...,
-        encoding: str | None = ...,
-        newline: str | None = ...,
-        suffix: str | None = ...,
-        prefix: str | None = ...,
-        dir: str | None = ...,
-        *,
-        errors: str | None = ...,
-    ): ...
-
-    def __init__(
-        self,
-        max_size: int = 0,
-        mode: OpenBinaryMode | OpenTextMode = "w+b",
-        buffering: int = -1,
-        encoding: str | None = None,
-        newline: str | None = None,
-        suffix: str | None = None,
-        prefix: str | None = None,
-        dir: str | None = None,
-        *,
-        errors: str | None = None,
-    ) -> None:
-        self._tempfile_params: dict[str, Any] = {
-            "mode": mode,
-            "buffering": buffering,
-            "encoding": encoding,
-            "newline": newline,
-            "suffix": suffix,
-            "prefix": prefix,
-            "dir": dir,
-            "errors": errors,
-        }
-        self._max_size = max_size
-        if "b" in mode:
-            super().__init__(BytesIO())  # type: ignore[arg-type]
-        else:
-            super().__init__(
-                TextIOWrapper(  # type: ignore[arg-type]
-                    BytesIO(),
-                    encoding=encoding,
-                    errors=errors,
-                    newline=newline,
-                    write_through=True,
-                )
-            )
-
-    async def aclose(self) -> None:
-        if not self._rolled:
-            self._fp.close()
-            return
-
-        await super().aclose()
-
-    async def _check(self) -> None:
-        if self._rolled or self._fp.tell() <= self._max_size:
-            return
-
-        await self.rollover()
-
-    async def rollover(self) -> None:
-        if self._rolled:
-            return
-
-        self._rolled = True
-        buffer = self._fp
-        buffer.seek(0)
-        self._fp = await to_thread.run_sync(
-            lambda: tempfile.TemporaryFile(**self._tempfile_params)
-        )
-        await self.write(buffer.read())
-        buffer.close()
-
-    @property
-    def closed(self) -> bool:
-        return self._fp.closed
-
-    async def read(self, size: int = -1) -> AnyStr:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.read(size)
-
-        return await super().read(size)  # type: ignore[return-value]
-
-    async def read1(self: SpooledTemporaryFile[bytes], size: int = -1) -> bytes:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.read1(size)
-
-        return await super().read1(size)
-
-    async def readline(self) -> AnyStr:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.readline()
-
-        return await super().readline()  # type: ignore[return-value]
-
-    async def readlines(self) -> list[AnyStr]:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.readlines()
-
-        return await super().readlines()  # type: ignore[return-value]
-
-    async def readinto(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.readinto(b)
-
-        return await super().readinto(b)
-
-    async def readinto1(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.readinto1(b)
-
-        return await super().readinto1(b)
-
-    async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.seek(offset, whence)
-
-        return await super().seek(offset, whence)
-
-    async def tell(self) -> int:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.tell()
-
-        return await super().tell()
-
-    async def truncate(self, size: int | None = None) -> int:
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            return self._fp.truncate(size)
-
-        return await super().truncate(size)
-
-    @overload
-    async def write(self: SpooledTemporaryFile[bytes], b: ReadableBuffer) -> int: ...
-    @overload
-    async def write(self: SpooledTemporaryFile[str], b: str) -> int: ...
-
-    async def write(self, b: ReadableBuffer | str) -> int:
-        """
-        Asynchronously write data to the spooled temporary file.
-
-        If the file has not yet been rolled over, the data is written synchronously,
-        and a rollover is triggered if the size exceeds the maximum size.
-
-        :param s: The data to write.
-        :return: The number of bytes written.
-        :raises RuntimeError: If the underlying file is not initialized.
-
-        """
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            result = self._fp.write(b)
-            await self._check()
-            return result
-
-        return await super().write(b)  # type: ignore[misc]
-
-    @overload
-    async def writelines(
-        self: SpooledTemporaryFile[bytes], lines: Iterable[ReadableBuffer]
-    ) -> None: ...
-    @overload
-    async def writelines(
-        self: SpooledTemporaryFile[str], lines: Iterable[str]
-    ) -> None: ...
-
-    async def writelines(self, lines: Iterable[str] | Iterable[ReadableBuffer]) -> None:
-        """
-        Asynchronously write a list of lines to the spooled temporary file.
-
-        If the file has not yet been rolled over, the lines are written synchronously,
-        and a rollover is triggered if the size exceeds the maximum size.
-
-        :param lines: An iterable of lines to write.
-        :raises RuntimeError: If the underlying file is not initialized.
-
-        """
-        if not self._rolled:
-            await checkpoint_if_cancelled()
-            result = self._fp.writelines(lines)
-            await self._check()
-            return result
-
-        return await super().writelines(lines)  # type: ignore[misc]
-
-
-class TemporaryDirectory(Generic[AnyStr]):
-    """
-    An asynchronous temporary directory that is created and cleaned up automatically.
-
-    This class provides an asynchronous context manager for creating a temporary
-    directory. It wraps Python's standard :class:`~tempfile.TemporaryDirectory` to
-    perform directory creation and cleanup operations in a background thread.
-
-    :param suffix: Suffix to be added to the temporary directory name.
-    :param prefix: Prefix to be added to the temporary directory name.
-    :param dir: The parent directory where the temporary directory is created.
-    :param ignore_cleanup_errors: Whether to ignore errors during cleanup
-    :param delete: Whether to delete the directory upon closing (Python 3.12+).
-    """
-
-    def __init__(
-        self,
-        suffix: AnyStr | None = None,
-        prefix: AnyStr | None = None,
-        dir: AnyStr | None = None,
-        *,
-        ignore_cleanup_errors: bool = False,
-        delete: bool = True,
-    ) -> None:
-        self.suffix: AnyStr | None = suffix
-        self.prefix: AnyStr | None = prefix
-        self.dir: AnyStr | None = dir
-        self.ignore_cleanup_errors = ignore_cleanup_errors
-        self.delete = delete
-
-        self._tempdir: tempfile.TemporaryDirectory | None = None
-
-    async def __aenter__(self) -> str:
-        params: dict[str, Any] = {
-            "suffix": self.suffix,
-            "prefix": self.prefix,
-            "dir": self.dir,
-            "ignore_cleanup_errors": self.ignore_cleanup_errors,
-        }
-        if sys.version_info >= (3, 12):
-            params["delete"] = self.delete
-
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**params)
-        )
-        return await to_thread.run_sync(self._tempdir.__enter__)
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        if self._tempdir is not None:
-            with CancelScope(shield=True):
-                await to_thread.run_sync(
-                    self._tempdir.__exit__, exc_type, exc_value, traceback
-                )
-
-    async def cleanup(self) -> None:
-        if self._tempdir is not None:
-            await to_thread.run_sync(self._tempdir.cleanup)
-
-
-@overload
-async def mkstemp(
-    suffix: str | None = None,
-    prefix: str | None = None,
-    dir: str | None = None,
-    text: bool = False,
-) -> tuple[int, str]: ...
-
-
-@overload
-async def mkstemp(
-    suffix: bytes | None = None,
-    prefix: bytes | None = None,
-    dir: bytes | None = None,
-    text: bool = False,
-) -> tuple[int, bytes]: ...
-
-
-async def mkstemp(
-    suffix: AnyStr | None = None,
-    prefix: AnyStr | None = None,
-    dir: AnyStr | None = None,
-    text: bool = False,
-) -> tuple[int, str | bytes]:
-    """
-    Asynchronously create a temporary file and return an OS-level handle and the file
-    name.
-
-    This function wraps `tempfile.mkstemp` and executes it in a background thread.
-
-    :param suffix: Suffix to be added to the file name.
-    :param prefix: Prefix to be added to the file name.
-    :param dir: Directory in which the temporary file is created.
-    :param text: Whether the file is opened in text mode.
-    :return: A tuple containing the file descriptor and the file name.
-
-    """
-    return await to_thread.run_sync(tempfile.mkstemp, suffix, prefix, dir, text)
-
-
-@overload
-async def mkdtemp(
-    suffix: str | None = None,
-    prefix: str | None = None,
-    dir: str | None = None,
-) -> str: ...
-
-
-@overload
-async def mkdtemp(
-    suffix: bytes | None = None,
-    prefix: bytes | None = None,
-    dir: bytes | None = None,
-) -> bytes: ...
-
-
-async def mkdtemp(
-    suffix: AnyStr | None = None,
-    prefix: AnyStr | None = None,
-    dir: AnyStr | None = None,
-) -> str | bytes:
-    """
-    Asynchronously create a temporary directory and return its path.
-
-    This function wraps `tempfile.mkdtemp` and executes it in a background thread.
-
-    :param suffix: Suffix to be added to the directory name.
-    :param prefix: Prefix to be added to the directory name.
-    :param dir: Parent directory where the temporary directory is created.
-    :return: The path of the created temporary directory.
-
-    """
-    return await to_thread.run_sync(tempfile.mkdtemp, suffix, prefix, dir)
-
-
-async def gettempdir() -> str:
-    """
-    Asynchronously return the name of the directory used for temporary files.
-
-    This function wraps `tempfile.gettempdir` and executes it in a background thread.
-
-    :return: The path of the temporary directory as a string.
-
-    """
-    return await to_thread.run_sync(tempfile.gettempdir)
-
-
-async def gettempdirb() -> bytes:
-    """
-    Asynchronously return the name of the directory used for temporary files in bytes.
-
-    This function wraps `tempfile.gettempdirb` and executes it in a background thread.
-
-    :return: The path of the temporary directory as bytes.
-
-    """
-    return await to_thread.run_sync(tempfile.gettempdirb)

venv/lib/python3.11/site-packages/anyio/_core/_testing.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Awaitable, Generator
-from typing import Any, cast
-
-from ._eventloop import get_async_backend
-
-
-class TaskInfo:
-    """
-    Represents an asynchronous task.
-
-    :ivar int id: the unique identifier of the task
-    :ivar parent_id: the identifier of the parent task, if any
-    :vartype parent_id: Optional[int]
-    :ivar str name: the description of the task (if any)
-    :ivar ~collections.abc.Coroutine coro: the coroutine object of the task
-    """
-
-    __slots__ = "_name", "coro", "id", "name", "parent_id"
-
-    def __init__(
-        self,
-        id: int,
-        parent_id: int | None,
-        name: str | None,
-        coro: Generator[Any, Any, Any] | Awaitable[Any],
-    ):
-        func = get_current_task
-        self._name = f"{func.__module__}.{func.__qualname__}"
-        self.id: int = id
-        self.parent_id: int | None = parent_id
-        self.name: str | None = name
-        self.coro: Generator[Any, Any, Any] | Awaitable[Any] = coro
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, TaskInfo):
-            return self.id == other.id
-
-        return NotImplemented
-
-    def __hash__(self) -> int:
-        return hash(self.id)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
-
-    def has_pending_cancellation(self) -> bool:
-        """
-        Return ``True`` if the task has a cancellation pending, ``False`` otherwise.
-
-        """
-        return False
-
-
-def get_current_task() -> TaskInfo:
-    """
-    Return the current task.
-
-    :return: a representation of the current task
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().get_current_task()
-
-
-def get_running_tasks() -> list[TaskInfo]:
-    """
-    Return a list of running tasks in the current event loop.
-
-    :return: a list of task info objects
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return cast("list[TaskInfo]", get_async_backend().get_running_tasks())
-
-
-async def wait_all_tasks_blocked() -> None:
-    """Wait until all other tasks are waiting for something."""
-    await get_async_backend().wait_all_tasks_blocked()

venv/lib/python3.11/site-packages/anyio/_core/_typedattr.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-import sys
-from collections.abc import Callable, Mapping
-from typing import Any, TypeVar, final, overload
-
-from ._exceptions import TypedAttributeLookupError
-
-if sys.version_info < (3, 15):
-    from typing_extensions import sentinel
-
-T_Attr = TypeVar("T_Attr")
-T_Default = TypeVar("T_Default")
-undefined = sentinel("undefined")
-
-
-def typed_attribute() -> Any:
-    """Return a unique object, used to mark typed attributes."""
-    return object()
-
-
-class TypedAttributeSet:
-    """
-    Superclass for typed attribute collections.
-
-    Checks that every public attribute of every subclass has a type annotation.
-    """
-
-    def __init_subclass__(cls) -> None:
-        annotations: dict[str, Any] = getattr(cls, "__annotations__", {})
-        for attrname in dir(cls):
-            if not attrname.startswith("_") and attrname not in annotations:
-                raise TypeError(
-                    f"Attribute {attrname!r} is missing its type annotation"
-                )
-
-        super().__init_subclass__()
-
-
-class TypedAttributeProvider:
-    """Base class for classes that wish to provide typed extra attributes."""
-
-    @property
-    def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
-        """
-        A mapping of the extra attributes to callables that return the corresponding
-        values.
-
-        If the provider wraps another provider, the attributes from that wrapper should
-        also be included in the returned mapping (but the wrapper may override the
-        callables from the wrapped instance).
-
-        """
-        return {}
-
-    @overload
-    def extra(self, attribute: T_Attr) -> T_Attr: ...
-
-    @overload
-    def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default: ...
-
-    @final
-    def extra(self, attribute: Any, default: object = undefined) -> object:
-        """
-        extra(attribute, default=undefined)
-
-        Return the value of the given typed extra attribute.
-
-        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to
-            look for
-        :param default: the value that should be returned if no value is found for the
-            attribute
-        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default
-            value was given
-
-        """
-        try:
-            getter = self.extra_attributes[attribute]
-        except KeyError:
-            if default is undefined:
-                raise TypedAttributeLookupError("Attribute not found") from None
-            else:
-                return default
-
-        return getter()

venv/lib/python3.11/site-packages/anyio/_lazyimport.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "fix_package_names",
-    "install_lazy_importer",
-    "set_deprecated_aliases",
-)
-
-import ast
-import inspect
-import sys
-import warnings
-from importlib import import_module
-from types import ModuleType
-from typing import Any
-
-
-def install_lazy_importer() -> bool:
-    module_globals = sys._getframe(1).f_globals
-    module_name = module_globals["__name__"]
-    module_prefix = module_name + "."
-    module = sys.modules[module_name]
-    lazy_map, deprecated_aliases = _build_lazy_map(module)
-    names = sorted(lazy_map)
-
-    # Delete symbols that are not part of the API
-    del module_globals["TYPE_CHECKING"]
-    del module_globals["install_lazy_importer"]
-
-    if not lazy_map and not deprecated_aliases:
-        return False
-
-    def __getattr__(name: str) -> Any:
-        if new_name := deprecated_aliases.get(name):
-            emit_deprecation_warning(module_name, name, new_name)
-            target_mod, target_attr = new_name.rsplit(".", 1)
-        else:
-            try:
-                target_mod, target_attr = lazy_map[name]
-            except KeyError:
-                raise AttributeError(
-                    f"module {module_name!r} has no attribute {name!r}"
-                ) from None
-
-        imported = import_module(target_mod, module_name)
-        value = getattr(imported, target_attr)
-
-        # patch the module name to match
-        if (
-            getattr(value, "__module__", "").startswith(module_prefix)
-            and name not in deprecated_aliases
-        ):
-            value.__module__ = module_name
-
-        module_globals[name] = value
-        return value
-
-    def __dir__() -> list[str]:
-        return names
-
-    module_globals["__dir__"] = __dir__
-    module_globals["__getattr__"] = __getattr__
-    module_globals.pop("fix_package_names", None)
-    module_globals.pop("set_deprecated_aliases", None)
-    return True
-
-
-def fix_package_names() -> None:
-    module_globals = sys._getframe(1).f_globals
-    module_prefix = module_globals["__name__"] + "."
-    del module_globals[fix_package_names.__name__]
-    for value in module_globals.values():
-        if modname := getattr(value, "__module__", ""):
-            if modname.startswith(module_prefix):
-                parts = modname.split(".")
-                value.__module__ = ".".join(
-                    part for part in parts if not part.startswith("_")
-                )
-
-
-def emit_deprecation_warning(module_name: str, name: str, target: str) -> None:
-    warnings.warn(
-        f"The {module_name}.{name} alias is deprecated, use {target} instead.",
-        DeprecationWarning,
-        stacklevel=3,
-    )
-
-
-def set_deprecated_aliases(aliases: dict[str, str]) -> None:
-    module_globals = sys._getframe(1).f_globals
-    module_name = module_globals["__name__"]
-    del module_globals[set_deprecated_aliases.__name__]
-
-    def __getattr__(name: str) -> Any:
-        try:
-            target = aliases[name]
-        except KeyError:
-            raise AttributeError(
-                f"module {module_name!r} has no attribute {name!r}"
-            ) from None
-
-        emit_deprecation_warning(module_name, name, target)
-        target_modname, attrname = target.rsplit(".", 1)
-        module = import_module(target_modname)
-        return getattr(module, attrname)
-
-    sys.modules[module_name].__dict__["__getattr__"] = __getattr__
-
-
-def _build_lazy_map(
-    module: ModuleType,
-) -> tuple[dict[str, tuple[str, str]], dict[str, str]]:
-    try:
-        source = inspect.getsource(module)
-    except OSError:
-        return {}, {}
-
-    tree = compile(source, module.__file__ or "", "exec", ast.PyCF_ONLY_AST)
-    assert isinstance(tree, ast.Module)
-    out: dict[str, tuple[str, str]] = {}
-    deprecated_aliases: dict[str, str] = {}
-
-    for node in tree.body:
-        if not isinstance(node, ast.If) or not _is_type_checking_block(node.test):
-            continue
-
-        for stmt in node.body:
-            match stmt:
-                case ast.ImportFrom():
-                    base = "." * stmt.level + (stmt.module or "")
-                    for alias in stmt.names:
-                        if alias.name == "*":
-                            raise RuntimeError("star imports not supported")
-
-                        exported = alias.asname or alias.name
-                        out[exported] = (base, alias.name)
-                case ast.Expr() if isinstance(stmt.value, ast.Call):
-                    call = stmt.value
-                    if (
-                        isinstance(call.func, ast.Name)
-                        and call.func.id == "set_deprecated_aliases"
-                    ):
-                        arg0 = call.args[0]
-                        assert isinstance(arg0, ast.Dict)
-                        for key, value in zip(arg0.keys, arg0.values, strict=True):
-                            assert isinstance(key, ast.Constant)
-                            assert isinstance(key.value, str)
-                            assert isinstance(value, ast.Constant)
-                            assert isinstance(value.value, str)
-                            deprecated_aliases[key.value] = value.value
-
-    return out, deprecated_aliases
-
-
-def _is_type_checking_block(test: ast.AST) -> bool:
-    if not isinstance(test, ast.BoolOp):
-        return False
-
-    subtest = test.values[0]
-    match subtest:
-        case ast.Name():
-            return subtest.id == "TYPE_CHECKING"
-        case ast.Attribute():
-            return (
-                isinstance(subtest.value, ast.Name)
-                and subtest.value.id == "typing"
-                and subtest.attr == "TYPE_CHECKING"
-            )
-        case _:
-            return False

venv/lib/python3.11/site-packages/anyio/abc/__init__.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from .._lazyimport import (
-    fix_package_names,
-    install_lazy_importer,
-    set_deprecated_aliases,
-)
-
-if TYPE_CHECKING or not install_lazy_importer():
-    from ._eventloop import AsyncBackend as AsyncBackend
-    from ._resources import AsyncResource as AsyncResource
-    from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket
-    from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket
-    from ._sockets import IPAddressType as IPAddressType
-    from ._sockets import IPSockAddrType as IPSockAddrType
-    from ._sockets import SocketAttribute as SocketAttribute
-    from ._sockets import SocketListener as SocketListener
-    from ._sockets import SocketStream as SocketStream
-    from ._sockets import UDPPacketType as UDPPacketType
-    from ._sockets import UDPSocket as UDPSocket
-    from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType
-    from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket
-    from ._sockets import UNIXSocketStream as UNIXSocketStream
-    from ._streams import AnyByteReceiveStream as AnyByteReceiveStream
-    from ._streams import AnyByteSendStream as AnyByteSendStream
-    from ._streams import AnyByteStream as AnyByteStream
-    from ._streams import AnyByteStreamConnectable as AnyByteStreamConnectable
-    from ._streams import (
-        AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream,
-    )
-    from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream
-    from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream
-    from ._streams import ByteReceiveStream as ByteReceiveStream
-    from ._streams import ByteSendStream as ByteSendStream
-    from ._streams import ByteStream as ByteStream
-    from ._streams import ByteStreamConnectable as ByteStreamConnectable
-    from ._streams import Listener as Listener
-    from ._streams import ObjectReceiveStream as ObjectReceiveStream
-    from ._streams import ObjectSendStream as ObjectSendStream
-    from ._streams import ObjectStream as ObjectStream
-    from ._streams import ObjectStreamConnectable as ObjectStreamConnectable
-    from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream
-    from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream
-    from ._streams import UnreliableObjectStream as UnreliableObjectStream
-    from ._subprocesses import Process as Process
-    from ._tasks import TaskGroup as TaskGroup
-    from ._tasks import TaskStatus as TaskStatus
-    from ._testing import TestRunner as TestRunner
-
-    fix_package_names()
-    set_deprecated_aliases(
-        {
-            "CapacityLimiter": "anyio.CapacityLimiter",
-            "Condition": "anyio.Condition",
-            "Event": "anyio.Event",
-            "Lock": "anyio.Lock",
-            "Semaphore": "anyio.Semaphore",
-            "CancelScope": "anyio.CancelScope",
-            "BlockingPortal": "anyio.from_thread.BlockingPortal",
-        }
-    )