pokerbots-dev 0.1.4__tar.gz → 0.1.6__tar.gz

{pokerbots_dev-0.1.4 → pokerbots_dev-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pokerbots-dev
-Version: 0.1.4
+Version: 0.1.6
 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.4 → pokerbots_dev-0.1.6}/pyproject.toml

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

pokerbots_dev-0.1.6/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.4 → pokerbots_dev-0.1.6}/src/pokerbots_cli/commands/account.py

@@ -6,10 +6,11 @@ from pathlib import Path
 
 from .. import auth
 from ..api import call
-from ..fmt import INK, PAPER, colored, money, place, signed, table, when
+from ..fmt import INK, PAPER, colored, held, money, place, signed, table, when
 
 MAX_UPLOAD = 1 << 20
 WATCH_SECONDS = 5
+SEATS = 6
 ATTEST = "I am 18 or older, and paid skill competitions are allowed where I am. [y/N] "
 
 
@@ -43,7 +44,11 @@ def upload(args):
 def deploy(args):
     mode = "live" if args.live else "paper"
     if mode == "live" and not call("GET", "/me")["attested"]:
-        if input(ATTEST).strip().lower() != "y":
+        try:
+            agreed = input(ATTEST).strip().lower() == "y"
+        except EOFError:
+            agreed = False
+        if not agreed:
             sys.exit("not deployed")
         call("POST", "/attest")
     call("POST", "/deployments", {"mode": mode, "version": int(args.version.lstrip("v"))})
@@ -56,13 +61,29 @@ def stop(args):
     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 note(me, mode):
+    """Why live games might not be starting."""
+    if mode != "live":
+        return ""
+    if me["balance"] < me["buy_in"]:
+        return f"  paused: balance below {money(me['buy_in'])}"
+    if me["live_ready"] < SEATS:
+        return f"  waiting for players ({me['live_ready']} of {SEATS} ready)"
+    return ""
+
+
 def report():
     me = call("GET", "/me")
     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 += [["balance", money(me["balance"])], ["wallet", me["wallet"] or "-"]]
+        rows.append([mode, f"v{d['version']}  rating {d['rating']:.0f}  games {d['games']}  today {d['today']}  {rank(mode)}{note(me, mode)}" if d else "-"])
+    rows += [["balance", f"{money(me['balance'])} on pokerbots, for live buy-ins"], ["wallet", held(me)]]
     text = table(rows, labels=True)
     games = call("GET", "/games")
     if games:
@@ -76,16 +97,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 +126,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 +159,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.4 → pokerbots_dev-0.1.6}/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.6/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.4 → pokerbots_dev-0.1.6}/src/pokerbots_cli/commands/local.py

@@ -2,6 +2,7 @@ import importlib.util
 import pydoc
 import random
 import shutil
+import subprocess
 import sys
 from importlib import resources
 from pathlib import Path
@@ -67,6 +68,17 @@ def test(args):
         return 1
 
 
+def upgrade(args):
+    """Upgrade with whichever installer pb came from; --refresh skips uv's stale package index."""
+    if shutil.which("uv"):
+        command = ["uv", "tool", "upgrade", "--refresh", "pokerbots-dev"]
+    elif shutil.which("pipx"):
+        command = ["pipx", "upgrade", "pokerbots-dev"]
+    else:
+        command = [sys.executable, "-m", "pip", "install", "--upgrade", "pokerbots-dev"]
+    return subprocess.call(command)
+
+
 def register(sub):
     p = sub.add_parser("docs", help="show the docs")
     p.add_argument("--plain", action="store_true", help="no pager, for agents")
@@ -81,3 +93,5 @@ def register(sub):
     p.add_argument("--games", type=int, default=100)
     p.add_argument("--seed", type=int)
     p.set_defaults(run=test)
+
+    sub.add_parser("upgrade", help="upgrade pb to the latest version").set_defaults(run=upgrade)

{pokerbots_dev-0.1.4 → pokerbots_dev-0.1.6}/src/pokerbots_cli/commands/money.py

@@ -2,7 +2,7 @@ import sys
 
 from .. import wallet as keys
 from ..api import call
-from ..fmt import money, parse_money, table
+from ..fmt import held, money, parse_money, table
 
 
 def registered_key():
@@ -16,10 +16,12 @@ def registered_key():
 
 def wallet(args):
     _, address, me = registered_key()
-    rows = [["address", address], ["balance", money(me["balance"])]]
+    me = call("GET", "/me")
+    yours = [["address", address], ["send", "USDC on Solana only (not SOL)"], ["wallet", held(me)]]
+    ours = [["balance", f"{money(me['balance'])} on pokerbots, for live buy-ins"]]
     if me["withdraw_to"] and me["withdraw_to"] != address:
-        rows.append(["withdraws to", me["withdraw_to"]])
-    print(table(rows, labels=True))
+        ours.append(["withdraws to", me["withdraw_to"]])
+    print(table(yours, labels=True) + "\n" + "-" * 3 + "\n" + table(ours, labels=True))
 
 
 def deposit(args):

{pokerbots_dev-0.1.4 → pokerbots_dev-0.1.6}/src/pokerbots_cli/docs.md

@@ -10,7 +10,10 @@ start
   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
+  pb upgrade                 upgrade pb
 
 money
   pb wallet                  your Solana wallet address and balance
@@ -43,12 +46,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
@@ -77,6 +102,19 @@ game
 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.4 → pokerbots_dev-0.1.6}/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,45 +120,79 @@ 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)
             previous = level
-            eligible = [p for p in live if p.committed >= level]
+            # nobody live matched this level: the chips were uncalled and go back to whoever bet them
+            eligible = [p for p in live if p.committed >= level] or [p for p in self.players if p.committed >= level]
             top = max(strength.get(p.seat, ()) for p in eligible)
             winners = [p for p in eligible if strength.get(p.seat, ()) == top]
             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 +200,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.4 → pokerbots_dev-0.1.6}/src/pokerbots_cli/fmt.py

@@ -31,7 +31,18 @@ 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 held(me):
+    """The wallet line: USDC in the player's own wallet, with a hint when it is SOL instead."""
+    if me.get("wallet_usdc") is None:
+        return "-"
+    text = f"{money(me['wallet_usdc'])} USDC in your wallet, ready to deposit"
+    if not me["wallet_usdc"] and me.get("wallet_sol"):
+        text += f" ({me['wallet_sol']} SOL there; deposits need USDC)"
+    return text
 
 
 def signed(value, unit=""):

pokerbots_dev-0.1.6/src/pokerbots_cli/house.py

@@ -0,0 +1,47 @@
+import random
+
+from .cards import RANKS, best
+
+
+def strength(state):
+    """Rough 0-1 hand strength: hole cards preflop, then the made hand."""
+    hole = state["hole"]
+    if not state["board"]:
+        high, low = sorted((RANKS.index(c[0]) for c in hole), reverse=True)
+        suited = hole[0][1] == hole[1][1]
+        return min(1, (high + low) / 24 + 0.35 * (high == low) + 0.05 * suited)
+    return min(1, best(hole + state["board"])[0] / 4)
+
+
+class Style:
+    """A simple, sensible bot: calls with enough strength or pot odds, raises its strong hands."""
+
+    call_at = raise_at = aggression = 0.0
+
+    def __init__(self, rng=None):
+        self.rng = rng or random.Random()
+
+    def act(self, s):
+        hand = strength(s)
+        if "raise" in s["legal"] and hand >= self.raise_at and self.rng.random() < self.aggression:
+            return ("raise", min(s["max_raise"], max(s["min_raise"], s["current_bet"] + s["pot"] // 2)))
+        if "check" in s["legal"]:
+            return ("check",)
+        odds = s["to_call"] / (s["pot"] + s["to_call"])
+        return ("call",) if hand >= max(self.call_at, odds) else ("fold",)
+
+
+class Tight(Style):
+    call_at, raise_at, aggression = 0.6, 0.75, 0.7
+
+
+class Loose(Style):
+    call_at, raise_at, aggression = 0.3, 0.5, 0.5
+
+
+class Solid(Style):
+    call_at, raise_at, aggression = 0.45, 0.65, 0.5
+
+
+HOUSE = {"tight": Tight, "loose": Loose, "solid": Solid}
+BOTS = (Tight, Loose, Solid, Tight, Loose)

pokerbots_dev-0.1.6/tests/test_engine.py

@@ -0,0 +1,59 @@
+import random
+
+from pokerbots_cli import engine
+from pokerbots_cli.agent import Agent
+from pokerbots_cli.house import BOTS, Loose
+
+
+def shove(state):
+    if "raise" in state["legal"]:
+        return ("raise", state["max_raise"])
+    return ("call",) if "call" in state["legal"] else ("check",)
+
+
+def test_games_conserve_chips_and_rank_everyone():
+    rng = random.Random(1)
+    for _ in range(20):
+        result = engine.play([Agent(Loose(rng))] + [Agent(cls()) for cls in BOTS], rng)
+        assert sum(result.stacks) == 6 * engine.STACK
+        assert sorted(result.places) == list(range(6))
+        assert result.hands <= engine.MAX_HANDS
+
+
+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], 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), 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))
+
+
+def test_uncalled_chips_return():
+    players = [engine.Player(0, lambda s: ("fold",), 14), engine.Player(1, lambda s: ("fold",), 1000)]
+    engine.Hand(67, players, 1, list(engine.DECK), engine.Game(["a", "b"])).play()
+    assert [p.stack for p in players] == [28, 986]

{pokerbots_dev-0.1.4 → pokerbots_dev-0.1.6}/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.4/src/pokerbots_cli/commands/__init__.py

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

pokerbots_dev-0.1.4/src/pokerbots_cli/house.py

@@ -1,19 +0,0 @@
-import random
-
-
-class Caller:
-    def act(self, state):
-        return ("call",) if "call" in state["legal"] else ("check",)
-
-
-class Raiser:
-    def __init__(self, rng=None):
-        self.rng = rng or random.Random()
-
-    def act(self, state):
-        if "raise" in state["legal"] and self.rng.random() < 0.3:
-            return ("raise", min(state["max_raise"], state["min_raise"] + self.rng.randint(0, state["pot"])))
-        return Caller().act(state)
-
-
-BOTS = (Caller, Raiser, Caller, Raiser, Caller)

pokerbots_dev-0.1.4/tests/test_engine.py

@@ -1,36 +0,0 @@
-import random
-
-from pokerbots_cli import engine
-from pokerbots_cli.agent import Agent
-from pokerbots_cli.house import BOTS, Raiser
-
-
-def shove(state):
-    if "raise" in state["legal"]:
-        return ("raise", state["max_raise"])
-    return ("call",) if "call" in state["legal"] else ("check",)
-
-
-def test_games_conserve_chips_and_rank_everyone():
-    rng = random.Random(1)
-    for _ in range(20):
-        result = engine.play([Agent(Raiser(rng))] + [Agent(cls()) for cls in BOTS], rng)
-        assert sum(result.stacks) == 6 * engine.STACK
-        assert sorted(result.places) == list(range(6))
-        assert result.hands <= engine.MAX_HANDS
-
-
-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()
-    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()
-    assert seen[0]["seat"] == 1 and seen[0]["bets"] == [6, 3]
-    assert [p.stack for p in players] == [1003, 997]