Warum dein Poker Bot Timeouts hat: Ursachen und Async-Fixes

Ein Poker Bot Timeout foldet automatisch die Hand die du gerade haeltst. Pocket Aces, Nut Flush, egal: der Server verwirft die Aktion und dein Stack geht rueckwaerts. Das 120-Sekunden-Fenster klingt grosszuegig bis du einen echten Bot bei Hand #47 einer Sitzung dabei beobachtest wie er es ueberschreitet. Hier sind die Ursachen und wie du jede Variante behebst.

Was passiert bei einem Timeout?

Open Poker erzwingt ein hartes 120-Sekunden-Fenster von your_turn bis zu deiner action-Antwort. Bei Ueberschreitung erzwingt der Server einen Fold (oder Check). Dein Bot bleibt am Tisch, aber die Hand ist verloren. Wiederholte Timeouts fuehren zur Trennung. Vollstaendiges Timer-Verhalten in der Timeout-Referenz.

Timeouts neigen zu deinen staerksten Haenden. Bots denken laenger ueber wichtige Entscheidungen nach.

Warum sind 120 Sekunden nicht wirklich grosszuegig?

1. Synchrone Netzwerkaufrufe in deiner Entscheidungsschleife. Ursache #1. Jeder synchrone Aufruf blockiert den gesamten Bot.

2. Reconnects waehrend einer Entscheidung.

3. Garbage-Collection-Pausen bei lang laufenden Bots.

Wie findest du langsame Entscheidungen?

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')}")

Wie behebst du synchrone Netzwerkaufrufe?

Konvertiere alles zu async. Verwende httpx statt 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")

Wie wrappst du Entscheidungen mit 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)

Wie gehst du mit Reconnects um?

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

Was ist das Action-Timeout auf Open Poker? 120 Sekunden. Auto-Fold bei Ueberschreitung.

Warum hat mein Bot nur bei schwierigen Entscheidungen Timeouts? Weil schwierige Entscheidungen mehr Codepfade ausloesen.

Kann ich das Timeout verlaengern? Nein. 120 Sekunden sind fest fuer alle Bots.

Was ist eine vernuenftige Ziel-Latenz? Unter 200ms ist exzellent. Ueber 5 Sekunden erfordert Untersuchung.

Timeouts sind der unsichtbare Bug der Bot-Gewinnraten zerstoert. Die Loesung: logge jede Entscheidungslatenz, wrappe deine Hauptlogik in asyncio.wait_for(), verwende ueberall async Clients und habe einen sicheren Fallback. Baue deinen ersten Bot mit diesen Patterns von Anfang an.