Pourquoi ton Poker Bot Timeout : Causes et Fixes Async

Un timeout du poker bot fait auto-fold de la main que tu as en cours. Pocket aces, nut flush, peu importe : le serveur annule l'action et ton stack recule. La fenetre de 120 secondes parait genereuse jusqu'a ce que tu voies un vrai bot la depasser a la main #47 d'une session. Voici les causes et comment corriger chaque variante.

Que se passe-t-il quand ton poker bot timeout ?

Open Poker impose une fenetre rigide de 120 secondes entre your_turn et ta reponse action. En cas de depassement, le serveur force un fold (ou check). Ton bot reste a la table mais la main est perdue. Les timeouts repetes entrainent une deconnexion. Voir la reference des timeouts.

Les timeouts touchent plus tes mains les plus fortes. Les bots reflechissent plus longtemps sur les decisions importantes.

Pourquoi 120 secondes n'est pas vraiment genereux ?

1. Appels reseau synchrones dans ta boucle de decision. Cause #1. Chaque appel synchrone bloque tout le bot.

2. Reconnexions pendant une decision.

3. Pauses du garbage collector sur les bots longue duree.

Comment trouver les decisions lentes ?

import time
 
async def handle_your_turn(msg, ws):
    start = time.monotonic()
    try:
        action = await decide(msg)
        await ws.send(json.dumps({
            "type": "action",
            "action": action["type"],
            "amount": action.get("amount", 0),
            "client_action_id": f"a-{msg['turn_token'][:8]}",
            "turn_token": msg["turn_token"],
        }))
    finally:
        elapsed_ms = (time.monotonic() - start) * 1000
        if elapsed_ms > 1000:
            print(f"[SLOW] decision took {elapsed_ms:.0f}ms on hand {msg.get('hand_number')}")

Comment corriger les appels reseau synchrones ?

Convertis tout en async. Utilise httpx au lieu de requests :

import httpx
http = httpx.AsyncClient(timeout=3.0)
 
async def decide(msg):
    response = await http.get("https://api.example.com/equity")
    equity = response.json()["equity"]
    return ("call" if equity > 0.4 else "fold")

Comment wrapper les decisions avec un timeout ?

async def decide_with_fallback(msg):
    try:
        return await asyncio.wait_for(decide(msg), timeout=10.0)
    except asyncio.TimeoutError:
        return fallback_decision(msg)
 
def fallback_decision(msg):
    actions = {a["action"]: a for a in msg["valid_actions"]}
    if "check" in actions:
        return ("check", 0)
    if "call" in actions:
        call_amt = actions["call"]["amount"]
        if call_amt < msg.get("pot", 0) * 0.2:
            return ("call", call_amt)
    return ("fold", 0)

Comment gerer les reconnexions ?

while True:
    try:
        async with websockets.connect(WS_URL, additional_headers=headers) as ws:
            await ws.send(json.dumps({"type": "set_auto_rebuy", "enabled": True}))
            await ws.send(json.dumps({"type": "join_lobby", "buy_in": 2000}))
            async for raw in ws:
                msg = json.loads(raw)
                await handle_message(msg, ws)
    except websockets.ConnectionClosed:
        print("Connection lost, reconnecting in 2s...")
        await asyncio.sleep(2)

FAQ

Quel est le timeout d'action sur Open Poker ? 120 secondes. Auto-fold en cas de depassement.

Pourquoi mon bot ne timeout que sur les decisions difficiles ? Parce qu'elles declenchent plus de chemins de code.

Puis-je etendre le timeout ? Non. 120 secondes, fixe pour tous les bots.

Quelle est une latence cible raisonnable ? Moins de 200ms c'est excellent. Plus de 5 secondes, il faut investiguer.

Les timeouts sont le bug invisible qui detruit les winrates de bots. La solution : logge chaque latence de decision, wrappe ta logique principale dans asyncio.wait_for(), utilise des clients async partout, et aie un fallback sur. Construis ton premier bot avec ces patterns des le debut.