pokerbots-dev 0.1.3__tar.gz → 0.1.5__tar.gz

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pokerbots-dev
-Version: 0.1.3
+Version: 0.1.5
 Summary: pb: command-line client for pokerbots.dev
 Project-URL: Homepage, https://pokerbots.dev
 Project-URL: Source, https://github.com/pokerbots-dev/pokerbots

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pokerbots-dev"
-version = "0.1.3"
+version = "0.1.5"
 description = "pb: command-line client for pokerbots.dev"
 readme = "README.md"
 requires-python = ">=3.10"

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/agent.py

@@ -1,7 +1,8 @@
 import traceback
-from time import perf_counter
+from time import perf_counter, thread_time
 
-LIMIT = 0.020
+LIMIT = 0.020  # CPU seconds per decision
+WALL = 0.100  # backstop so a bot cannot stall the table
 
 
 def fallback(state):
@@ -19,7 +20,10 @@ def normalize(action, state):
 
 
 class Agent:
-    """Runs an untrusted bot: enforces the time limit and returns only legal actions."""
+    """Runs an untrusted bot: enforces the CPU and wall limits and returns only legal actions.
+
+    CPU time comes from bot.cpu() when the bot runs elsewhere (a sandboxed process), else this thread.
+    """
 
     def __init__(self, bot, limit=LIMIT):
         self.bot = bot
@@ -30,14 +34,15 @@ class Agent:
 
     def __call__(self, state):
         self.decisions += 1
-        start = perf_counter()
+        clock = getattr(self.bot, "cpu", thread_time)
+        wall, cpu = perf_counter(), clock()
         try:
             action = self.bot.act(state)
         except Exception:
             return self.fail(state, traceback.format_exc())
-        elapsed = perf_counter() - start
-        self.slowest = max(self.slowest, elapsed)
-        if elapsed > self.limit:
+        wall, cpu = perf_counter() - wall, clock() - cpu
+        self.slowest = max(self.slowest, cpu)
+        if cpu > self.limit or wall > WALL:
             self.late += 1
             return fallback(state)
         return normalize(action, state) or self.fail(state, f"invalid action {action!r}, legal {state['legal']}")

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/api.py

@@ -35,7 +35,7 @@ def call(method, path, body=None, data=None, headers=None):
             message = f"{e.code} {e.reason}"
         raise ApiError(message) from None
     except urllib.error.URLError as e:
-        raise ApiError(str(e.reason)) from None
+        raise ApiError(f"cannot reach {base()}: {e.reason}") from None
 
 
 def admin(method, path, body=None):

pokerbots_dev-0.1.5/src/pokerbots_cli/commands/__init__.py

@@ -0,0 +1,3 @@
+from . import account, admin, history, local, money
+
+MODULES = (account, history, local, money, admin)

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/commands/account.py

@@ -53,7 +53,12 @@ def deploy(args):
 def stop(args):
     mode = "live" if args.live else "paper"
     call("DELETE", f"/deployments/{mode}")
-    print(f"stopped {mode}")
+    print(f"stopped {mode}; games already queued will still play")
+
+
+def rank(mode):
+    board = call("GET", f"/leaderboard/{mode}")
+    return f"#{board['you']} of {board['ranked']}" if board["you"] else f"unranked until {board['min_games']} games"
 
 
 def report():
@@ -61,7 +66,7 @@ def report():
     rows = [["user", me["login"]], ["versions", " ".join(f"v{v}" for v in me["versions"]) or "-"]]
     for mode in ("paper", "live"):
         d = me["deployments"].get(mode)
-        rows.append([mode, f"v{d['version']}  rating {d['rating']:.0f}  games {d['games']}  today {d['today']}" if d else "-"])
+        rows.append([mode, f"v{d['version']}  rating {d['rating']:.0f}  games {d['games']}  today {d['today']}  {rank(mode)}" if d else "-"])
     rows += [["balance", money(me["balance"])], ["wallet", me["wallet"] or "-"]]
     text = table(rows, labels=True)
     games = call("GET", "/games")
@@ -76,16 +81,26 @@ def report():
     return text
 
 
-def status(args):
-    print(report())
+def leaderboard(mode):
+    board = call("GET", f"/leaderboard/{mode}")
+    live = mode == "live"
+    head = ["rank", "user", "rating", "games"] + (["won"] if live else [])
+    rows = [[i + 1, r["login"], f"{r['rating']:.0f}", r["games"]] + ([signed(r["won"], "money")] if live else [])
+            for i, r in enumerate(board["rows"])]
+    text = f"{mode} leaderboard\n\n" + (table([head] + rows, header=True) if rows else f"no bots with {board['min_games']} games yet")
+    you = f"#{board['you']} of {board['ranked']}" if board["you"] else f"unranked until {board['min_games']} games"
+    return text + "\n\n" + table([["you", you]], labels=True)
 
 
-def watch(args):
+def screen(render):
+    """Full-screen, flicker-free view in the homepage colours, redrawn until ctrl-c."""
+    if not sys.stdout.isatty():
+        return print(render())
     paint = f"\x1b[48;2;{INK}m\x1b[38;2;{PAPER}m" if colored() else ""
     sys.stdout.write("\x1b[?1049h\x1b[?25l" + paint + "\x1b[2J")
     try:
         while True:
-            lines = ["", *("  " + line for line in report().split("\n")), "", "  " + "ctrl-c to quit"]
+            lines = ["", *("  " + line for line in render().split("\n")), "", "  ctrl-c to quit"]
             sys.stdout.write("\x1b[H" + "".join(line + "\x1b[K\n" for line in lines) + "\x1b[J")
             sys.stdout.flush()
             time.sleep(WATCH_SECONDS)
@@ -95,8 +110,24 @@ def watch(args):
         sys.stdout.write("\x1b[0m\x1b[?25h\x1b[?1049l")
 
 
+def status(args):
+    print(report())
+
+
+def watch(args):
+    screen(report)
+
+
+def top(args):
+    screen(lambda: leaderboard("live" if args.live else "paper"))
+
+
 def register(sub):
     sub.add_parser("login", help="sign in with GitHub").set_defaults(run=login)
+    sub.add_parser("watch", help="status, live").set_defaults(run=watch)
+    p = sub.add_parser("top", help="leaderboard, live")
+    p.add_argument("--live", action="store_true", help="live play instead of paper")
+    p.set_defaults(run=top)
 
     p = sub.add_parser("upload", help="upload a new version")
     p.add_argument("dir", nargs="?", default=".")
@@ -112,4 +143,3 @@ def register(sub):
         p.set_defaults(run=run)
 
     sub.add_parser("status", help="your bot, rating, balance and recent games").set_defaults(run=status)
-    sub.add_parser("watch", help="status, live").set_defaults(run=watch)

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/commands/admin.py

@@ -26,7 +26,7 @@ def decide(args):
 
 
 def register(sub):
-    p = sub.add_parser("admin", help="operator commands")
+    p = sub.add_parser("admin")
     admin_sub = p.add_subparsers(metavar="command", required=True)
     admin_sub.add_parser("stats").set_defaults(run=stats)
     admin_sub.add_parser("withdrawals", help="pending withdrawals").set_defaults(run=withdrawals)

pokerbots_dev-0.1.5/src/pokerbots_cli/commands/history.py

@@ -0,0 +1,53 @@
+import json
+from datetime import date, timedelta
+from pathlib import Path
+from urllib.parse import urlencode
+
+from ..api import call
+
+DEFAULT_DAYS = 7
+
+
+def known_ids(directory):
+    return {json.loads(line)["id"] for f in directory.glob("*.jsonl") for line in f.read_text().splitlines() if line}
+
+
+def history(args):
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    have = known_ids(out)
+    params = {
+        "since": args.since or (date.today() - timedelta(days=DEFAULT_DAYS)).isoformat(),
+        "until": args.until or date.today().isoformat(),
+    }
+    if args.live or args.paper:
+        params["mode"] = "live" if args.live else "paper"
+    if args.all:
+        params["all"] = "1"
+    saved = skipped = 0
+    after = None
+    while True:
+        page = call("GET", "/history?" + urlencode({**params, **({"after": after} if after else {})}))
+        for game in page["games"]:
+            if game["id"] in have:
+                skipped += 1
+                continue
+            with open(out / f"{game['finished_at'][:10]}.jsonl", "a") as f:
+                f.write(json.dumps(game) + "\n")
+            saved += 1
+        after = page["next"]
+        if not after:
+            break
+    print(f"saved {saved} games to {out}/" + (f", {skipped} already there" if skipped else ""))
+
+
+def register(sub):
+    p = sub.add_parser("history", help="download finished games as JSON lines")
+    p.add_argument("--since", metavar="YYYY-MM-DD", help=f"default {DEFAULT_DAYS} days ago")
+    p.add_argument("--until", metavar="YYYY-MM-DD", help="default today")
+    mode = p.add_mutually_exclusive_group()
+    mode.add_argument("--paper", action="store_true")
+    mode.add_argument("--live", action="store_true")
+    p.add_argument("--all", action="store_true", help="every player's games, not just yours")
+    p.add_argument("-o", "--out", default="history", help="directory, default ./history")
+    p.set_defaults(run=history)

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/commands/local.py

@@ -58,9 +58,9 @@ def test(args):
         ["2nd", places.count(2)],
         ["avg place", f"{sum(places) / len(places):.1f}"],
         ["decisions", mine.decisions],
-        ["over 20 ms", mine.late],
+        ["late", mine.late],
         ["errors", mine.errors],
-        ["slowest", f"{mine.slowest * 1000:.2f} ms"],
+        ["slowest", f"{mine.slowest * 1000:.2f} ms cpu"],
     ]))
     if mine.error:
         print(f"\nfirst error\n{mine.error}")

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/commands/money.py

@@ -1,3 +1,5 @@
+import sys
+
 from .. import wallet as keys
 from ..api import call
 from ..fmt import money, parse_money, table
@@ -6,25 +8,32 @@ from ..fmt import money, parse_money, table
 def registered_key():
     key = keys.load_or_create()
     address = keys.address(key)
-    if call("GET", "/me")["wallet"] != address:
+    me = call("GET", "/me")
+    if me["wallet"] != address:
         call("PUT", "/wallet", {"address": address})
-    return key, address
+    return key, address, me
 
 
 def wallet(args):
-    _, address = registered_key()
-    print(table([["address", address], ["balance", money(call("GET", "/me")["balance"])]]))
+    _, address, me = registered_key()
+    rows = [["address", address], ["balance", money(me["balance"])]]
+    if me["withdraw_to"] and me["withdraw_to"] != address:
+        rows.append(["withdraws to", me["withdraw_to"]])
+    print(table(rows, labels=True))
 
 
 def deposit(args):
-    key, _ = registered_key()
+    key, _, _ = registered_key()
     prepared = call("POST", "/deposits", {"amount": parse_money(args.amount)})
     reply = call("POST", f"/deposits/{prepared['signature']}", {"transaction": keys.sign(prepared["transaction"], key)})
     print(f"deposit {reply['status']}: {money(reply['amount'])}")
 
 
 def withdraw(args):
-    registered_key()
+    _, address, me = registered_key()
+    if me["withdraw_to"] and me["withdraw_to"] != address:
+        sys.exit(f"withdrawals go to {me['withdraw_to']}, the wallet you last deposited from.\n"
+                 f"to use this wallet instead, deposit from it once: pb deposit 0.10")
     reply = call("POST", "/withdrawals", {"amount": parse_money(args.amount)})
     print(f"withdrawal {reply['status']}: {money(reply['amount'])}")
 

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/docs.md

@@ -7,9 +7,11 @@ start
   pb upload [dir]            upload a new version: v1, v2, ...
   pb deploy v1 --paper       play free games with v1
   pb deploy v1 --live        play for money with v1
-  pb stop --paper|--live     stop playing
+  pb stop --paper|--live     stop playing; queued games still play
   pb status                  versions, rating, balance, recent games
   pb watch                   the same, refreshed every 5 seconds
+  pb top [--live]            leaderboard: rating order, 20+ games; live shows won
+  pb history                 download your finished games, see history below
   pb docs [--plain]          show this
 
 money
@@ -19,7 +21,8 @@ money
 
   Your wallet key is ~/.config/pokerbots/wallet.json and never leaves your
   machine. Send USDC on Solana to its address, then deposit. We pay the
-  network fees. Large withdrawals may wait for review.
+  network fees. Withdrawals go to the wallet you last deposited from.
+  Large withdrawals may wait for review.
 
 bot.py
   class Bot:
@@ -29,8 +32,9 @@ bot.py
           return ("fold",)
 
   A new Bot is created for every game. act is called for every decision.
-  A late reply (over 20 ms), an error or an illegal action counts as
-  check, or fold if check is not legal. Uploads are the bot's directory,
+  Each decision gets 20 ms of CPU time, and must reply within 100 ms.
+  A late reply, an error or an illegal action counts as check, or fold
+  if check is not legal. Uploads are the bot's directory,
   up to 1 MB zipped. Bots run with the Python standard library only, no
   network and no file writes.
 
@@ -41,12 +45,34 @@ actions
   ("raise", n)    n is your total bet this round, from min_raise to max_raise
 
 state
-  hand         hand number, from 1
-  seat         your seat, 0-5
-  button       button seat
-  blinds       [small, big]
-  hole         your two cards, e.g. ["As", "Td"]
-  board        shared cards
+  hand          hand number, from 1
+  hands_left    hands until the game ends at 100
+  street        preflop, flop, turn or river
+  seat          your seat, 0-5
+  players       login by seat, or "house"
+  button        button seat
+  small_blind   small blind seat
+  big_blind     big blind seat
+  blinds        [small, big] amounts
+  hole          your two cards, e.g. ["As", "Td"]
+  board         shared cards
+  stacks_start  chips by seat when this hand began
+  stacks        chips behind, by seat
+  bets          chips bet this round, by seat
+  current_bet   the bet to match this round
+  pot           chips bet this hand
+  to_call       chips needed to call
+  legal         actions allowed now
+  min_raise     smallest raise total, when raise is legal
+  max_raise     all in, when raise is legal
+  live          seats still in the hand
+  all_in        seats in the hand with no chips behind
+  out           eliminated seats, first out first
+  actions       this hand so far, [cards on board, seat, action, bet this round]
+  past          finished hands this game: hand, board, shown (cards by seat,
+                null unless shown down), won (chips by seat)
+
+cards
   stacks       chips behind, by seat
   bets         chips bet this round, by seat
   pot          chips bet this hand
@@ -68,13 +94,26 @@ game
   blinds on hand n: n / 2n
   ends at last bot standing or 100 hands
   at 100 hands, places go by chips
-  20 ms per decision, else check/fold
+  20 ms CPU per decision, else check/fold
   up to 5 games a minute per bot
   paper tables are filled with house bots; live tables are 6 players
 
 rating
   Elo, from 1500; each game counts as a win over every bot placed below
 
+history
+  pb history [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--paper|--live] [--all] [-o dir]
+
+  One JSON line per finished game, one file per day: history/2026-10-29.jsonl.
+  Games appear 10 minutes after they end. Default: your games, last 7 days.
+  --all adds everyone's games. You see your own hole cards and any cards
+  shown down; folded cards stay hidden. Re-running skips games you have.
+
+  game   id, mode, finished_at, hands_played, you (your seat),
+         players [seat, user, place, rating_change, won ($, live)],
+         hands [hand, button, small_blind, big_blind, blinds, stacks_start,
+                hole, board, actions, shown, won]
+
 price
   paper   free, 1,000 games/day
 

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/engine.py

@@ -1,10 +1,11 @@
 import random
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from .cards import DECK, best
 
 STACK = 1000
 MAX_HANDS = 100
+STREETS = ("preflop", "flop", "turn", "river")
 
 
 @dataclass
@@ -28,31 +29,52 @@ class Player:
         self.committed += chips
 
 
+@dataclass
+class Game:
+    """What every hand of one game shares: names, finished hands, eliminations."""
+    names: list
+    max_hands: int = MAX_HANDS
+    past: list = field(default_factory=list)  # public summaries, as bots see them
+    hands: list = field(default_factory=list)  # full records, every hole card
+    out: list = field(default_factory=list)
+
+
 @dataclass
 class Result:
     places: list
     hands: int
     stacks: list
+    history: list
+
+
+def per_seat(n, values=None, default=None):
+    out = [default] * n
+    for seat, value in (values or {}).items():
+        out[seat] = value
+    return out
 
 
 class Hand:
-    def __init__(self, number, players, button, deck, seats):
+    def __init__(self, number, players, button, deck, game):
         self.number = number
         self.players = players
         self.button = button
         self.deck = deck
-        self.seats = seats
+        self.game = game
+        self.seats = len(game.names)
         self.blinds = [number, 2 * number]
         self.board = []
         self.log = []
 
     def play(self):
         n = len(self.players)
+        self.stacks_start = per_seat(self.seats, {p.seat: p.stack for p in self.players}, 0)
         for p in self.players:
             p.hole = (self.deck.pop(), self.deck.pop())
             p.bet = p.committed = 0
             p.folded = False
         small = self.button if n == 2 else (self.button + 1) % n
+        self.blind_seats = [self.players[small].seat, self.players[(small + 1) % n].seat]
         for i, blind in zip((small, (small + 1) % n), self.blinds):
             self.players[i].put(blind)
             self.record(self.players[i], "blind")
@@ -64,7 +86,7 @@ class Hand:
                 p.bet = 0
             self.board += [self.deck.pop() for _ in range(count)]
             self.betting((self.button + 1) % n, 0)
-        self.award()
+        self.finish(self.award())
 
     def betting(self, start, current):
         order = self.players[start:] + self.players[:start]
@@ -77,7 +99,7 @@ class Hand:
                 continue
             to_call = current - p.bet
             legal = ["fold", "call"] if to_call > 0 else ["check"]
-            state = self.state(p, legal, to_call)
+            state = self.state(p, legal, to_call, current)
             if others and p.stack > to_call:
                 legal.append("raise")
                 state["max_raise"] = p.bet + p.stack
@@ -98,29 +120,40 @@ class Hand:
     def record(self, p, action):
         self.log.append([len(self.board), p.seat, action, p.bet])
 
-    def state(self, p, legal, to_call):
+    def state(self, p, legal, to_call, current):
         stacks, bets = [0] * self.seats, [0] * self.seats
         for q in self.players:
             stacks[q.seat], bets[q.seat] = q.stack, q.bet
         return {
             "hand": self.number,
+            "hands_left": self.game.max_hands - self.number,
+            "street": STREETS[max(0, len(self.board) - 2)],
             "seat": p.seat,
+            "players": list(self.game.names),
             "button": self.players[self.button].seat,
+            "small_blind": self.blind_seats[0],
+            "big_blind": self.blind_seats[1],
             "blinds": list(self.blinds),
             "hole": list(p.hole),
             "board": list(self.board),
+            "stacks_start": list(self.stacks_start),
             "stacks": stacks,
             "bets": bets,
+            "current_bet": current,
             "pot": sum(q.committed for q in self.players),
             "to_call": to_call,
             "legal": legal,
             "live": [q.seat for q in self.players if not q.folded],
+            "all_in": [q.seat for q in self.players if not q.folded and q.stack == 0],
+            "out": list(self.game.out),
             "actions": [list(a) for a in self.log],
+            "past": list(self.game.past),
         }
 
     def award(self):
         live = [p for p in self.players if not p.folded]
         strength = {p.seat: best(p.hole + tuple(self.board)) for p in live} if len(live) > 1 else {}
+        won = {}
         previous = 0
         for level in sorted({p.committed for p in self.players}):
             pot = sum(min(p.committed, level) - min(p.committed, previous) for p in self.players)
@@ -131,12 +164,34 @@ class Hand:
             share, odd = divmod(pot, len(winners))
             for i, w in enumerate(winners):
                 w.stack += share + (i < odd)
+                won[w.seat] = won.get(w.seat, 0) + share + (i < odd)
+        return won
+
+    def finish(self, won):
+        shown = {p.seat: list(p.hole) for p in self.players if not p.folded} if sum(not p.folded for p in self.players) > 1 else {}
+        summary = {
+            "hand": self.number,
+            "board": list(self.board),
+            "shown": per_seat(self.seats, shown),
+            "won": per_seat(self.seats, won, 0),
+        }
+        self.game.past.append(summary)
+        self.game.hands.append({
+            **summary,
+            "button": self.players[self.button].seat,
+            "small_blind": self.blind_seats[0],
+            "big_blind": self.blind_seats[1],
+            "blinds": list(self.blinds),
+            "stacks_start": list(self.stacks_start),
+            "hole": per_seat(self.seats, {p.seat: list(p.hole) for p in self.players}),
+            "actions": [list(a) for a in self.log],
+        })
 
 
-def play(agents, rng=None, max_hands=MAX_HANDS):
+def play(agents, rng=None, max_hands=MAX_HANDS, names=None):
     rng = rng or random.Random()
     table = [Player(seat, agent) for seat, agent in enumerate(agents)]
-    busted = []
+    game = Game(list(names or [f"seat {i}" for i in range(len(table))]), max_hands)
     button = rng.randrange(len(table))
     hands = 0
     while hands < max_hands and sum(p.stack > 0 for p in table) > 1:
@@ -144,8 +199,8 @@ def play(agents, rng=None, max_hands=MAX_HANDS):
         alive = [p for p in table if p.stack > 0]
         b = next((i for i, p in enumerate(alive) if p.seat >= button), 0)
         before = {p.seat: p.stack for p in alive}
-        Hand(hands, alive, b, rng.sample(DECK, len(DECK)), len(table)).play()
-        busted += sorted((p.seat for p in alive if p.stack == 0), key=before.get)
+        Hand(hands, alive, b, rng.sample(DECK, len(DECK)), game).play()
+        game.out += sorted((p.seat for p in alive if p.stack == 0), key=before.get)
         button = alive[b].seat + 1
     standing = sorted((p for p in table if p.stack > 0), key=lambda p: -p.stack)
-    return Result([p.seat for p in standing] + busted[::-1], hands, [p.stack for p in table])
+    return Result([p.seat for p in standing] + game.out[::-1], hands, [p.stack for p in table], game.hands)

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/src/pokerbots_cli/fmt.py

@@ -31,7 +31,8 @@ def table(rows, labels=False, header=False):
 
 def money(micro):
     cents = round(micro / 10_000)
-    return f"{cents}¢" if abs(cents) < 100 else f"${cents / 100:,.2f}"
+    sign = "-" if cents < 0 else ""
+    return f"{cents}¢" if abs(cents) < 100 else f"{sign}${abs(cents) / 100:,.2f}"
 
 
 def signed(value, unit=""):

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/tests/test_agent.py

@@ -13,6 +13,12 @@ class Fixed:
         return self.reply(state)
 
 
+def busy(seconds):
+    end = time.thread_time() + seconds
+    while time.thread_time() < end:
+        pass
+
+
 def run(reply):
     agent = Agent(Fixed(reply))
     return agent(dict(STATE)), agent
@@ -25,8 +31,12 @@ def test_legal_actions_pass_and_raises_clamp():
 
 
 def test_bad_bots_fold():
-    action, agent = run(lambda s: time.sleep(0.03))
+    action, agent = run(lambda s: time.sleep(0.15))
+    assert action == ("fold",) and agent.late == 1
+    action, agent = run(lambda s: busy(0.03))
     assert action == ("fold",) and agent.late == 1
+    action, agent = run(lambda s: time.sleep(0.03) or ("call",))
+    assert action == ("call",) and agent.late == 0
     action, agent = run(lambda s: 1 / 0)
     assert action == ("fold",) and "ZeroDivisionError" in agent.error
     action, agent = run(lambda s: ("check",))

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/tests/test_cli.py

@@ -1,3 +1,5 @@
+import re
+
 import pytest
 
 from pokerbots_cli.main import main
@@ -14,7 +16,7 @@ def test_init_then_test(tmp_path, capsys):
     bot = tmp_path / "mybot"
     assert main(["init", str(bot)]) == 0
     assert main(["test", str(bot), "--games", "3", "--seed", "1"]) == 0
-    assert "errors      0" in capsys.readouterr().out
+    assert re.search(r"errors\s+0\n", capsys.readouterr().out)
 
 
 def test_docs_plain(capsys):

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/tests/test_engine.py

@@ -24,13 +24,30 @@ def test_side_pots():
     stacks = [100, 300, 300]
     players = [engine.Player(seat, shove, stack) for seat, stack in enumerate(stacks)]
     dealt = "Ah Ad Kh Kd Qh Qd 2c 7d 9h Js 4c".split()
-    engine.Hand(1, players, 0, dealt[::-1], 3).play()
+    engine.Hand(1, players, 0, dealt[::-1], engine.Game(["a", "b", "c"])).play()
     assert [p.stack for p in players] == [300, 400, 0]
 
 
 def test_heads_up_button_posts_small_blind():
     seen = []
     players = [engine.Player(s, lambda st: seen.append(st) or ("fold",)) for s in range(2)]
-    engine.Hand(3, players, 1, list(engine.DECK), 2).play()
+    engine.Hand(3, players, 1, list(engine.DECK), engine.Game(["a", "b"])).play()
     assert seen[0]["seat"] == 1 and seen[0]["bets"] == [6, 3]
     assert [p.stack for p in players] == [1003, 997]
+
+
+def test_state_and_history():
+    seen = []
+
+    def agent(state):
+        seen.append(state)
+        return shove(state) if state["seat"] == 0 else ("call",) if "call" in state["legal"] else ("check",)
+
+    result = engine.play([agent] * 6, random.Random(3), names=list("abcdef"))
+    last = seen[-1]
+    assert last["players"] == list("abcdef") and last["street"] in engine.STREETS
+    assert len(last["past"]) == last["hand"] - 1 and last["hands_left"] == engine.MAX_HANDS - last["hand"]
+    assert len(result.history) == result.hands
+    for h in result.history:
+        assert sum(h["won"]) > 0
+        assert all(h["shown"][s] in (None, h["hole"][s]) for s in range(6))

{pokerbots_dev-0.1.3 → pokerbots_dev-0.1.5}/tests/test_wallet.py

@@ -20,5 +20,5 @@ def test_sign_fills_our_slot_only():
 def test_b58_and_money():
     assert wallet.b58(bytes(32)) == "1" * 32
     assert wallet.b58(b"\x00\x01") == "12"
-    assert [money(100_000), money(370_000), money(4_200_000)] == ["10¢", "37¢", "$4.20"]
+    assert [money(100_000), money(370_000), money(4_200_000), money(-1_100_000)] == ["10¢", "37¢", "$4.20", "-$1.10"]
     assert parse_money("$0.10") == 100_000

pokerbots_dev-0.1.3/src/pokerbots_cli/commands/__init__.py

@@ -1,3 +0,0 @@
-from . import account, admin, local, money
-
-MODULES = (account, local, money, admin)