pokerbots-dev 0.0.1__tar.gz → 0.1.0__tar.gz

{pokerbots_dev-0.0.1 → pokerbots_dev-0.1.0}/.gitignore

@@ -9,3 +9,4 @@ node_modules/
 .wrangler/
 .dev.vars
 .env
+site/llms.txt

{pokerbots_dev-0.0.1 → pokerbots_dev-0.1.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: pokerbots-dev
-Version: 0.0.1
+Version: 0.1.0
 Summary: pb: command-line client for pokerbots.dev
 Project-URL: Homepage, https://pokerbots.dev
 Project-URL: Source, https://github.com/pokerbots-dev/pokerbots
 License-Expression: MIT
 Requires-Python: >=3.10
+Requires-Dist: cryptography>=42
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == 'dev'
 Description-Content-Type: text/markdown

{pokerbots_dev-0.0.1 → pokerbots_dev-0.1.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pokerbots-dev"
-version = "0.0.1"
+version = "0.1.0"
 description = "pb: command-line client for pokerbots.dev"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
-dependencies = []
+dependencies = ["cryptography>=42"]
 
 [project.optional-dependencies]
 dev = ["pytest>=8"]

pokerbots_dev-0.1.0/src/pokerbots_cli/agent.py

@@ -0,0 +1,48 @@
+import traceback
+from time import perf_counter
+
+LIMIT = 0.020
+
+
+def fallback(state):
+    return ("check",) if "check" in state["legal"] else ("fold",)
+
+
+def normalize(action, state):
+    if not isinstance(action, (tuple, list)) or not action or action[0] not in state["legal"]:
+        return None
+    if action[0] != "raise":
+        return (action[0],)
+    if len(action) < 2 or not isinstance(action[1], int) or isinstance(action[1], bool):
+        return None
+    return ("raise", min(max(action[1], state["min_raise"]), state["max_raise"]))
+
+
+class Agent:
+    """Runs an untrusted bot: enforces the time limit and returns only legal actions."""
+
+    def __init__(self, bot, limit=LIMIT):
+        self.bot = bot
+        self.limit = limit
+        self.decisions = self.late = self.errors = 0
+        self.slowest = 0.0
+        self.error = None
+
+    def __call__(self, state):
+        self.decisions += 1
+        start = perf_counter()
+        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:
+            self.late += 1
+            return fallback(state)
+        return normalize(action, state) or self.fail(state, f"invalid action {action!r}, legal {state['legal']}")
+
+    def fail(self, state, error):
+        self.errors += 1
+        self.error = self.error or error
+        return fallback(state)

pokerbots_dev-0.1.0/src/pokerbots_cli/api.py

@@ -0,0 +1,48 @@
+import json
+import os
+import urllib.error
+import urllib.request
+
+from . import auth
+
+
+class ApiError(Exception):
+    pass
+
+
+def base():
+    return os.environ.get("PB_API", "https://api.pokerbots.dev").rstrip("/")
+
+
+def call(method, path, body=None, data=None, headers=None):
+    headers = dict(headers or {})
+    if "CF-Access-Client-Id" not in headers:
+        credentials = auth.load()
+        if not credentials:
+            raise ApiError("not logged in: pb login")
+        headers["Authorization"] = f"Bearer {credentials['github_token']}"
+    if body is not None:
+        data = json.dumps(body).encode()
+        headers["Content-Type"] = "application/json"
+    request = urllib.request.Request(base() + path, data, headers, method=method)
+    try:
+        with urllib.request.urlopen(request) as response:
+            return json.load(response)
+    except urllib.error.HTTPError as e:
+        try:
+            message = json.load(e)["error"]
+        except (ValueError, KeyError):
+            message = f"{e.code} {e.reason}"
+        raise ApiError(message) from None
+    except urllib.error.URLError as e:
+        raise ApiError(str(e.reason)) from None
+
+
+def admin(method, path, body=None):
+    headers = {
+        "CF-Access-Client-Id": os.environ.get("CLOUDFLARE_ACCESS_CLIENT_ID", ""),
+        "CF-Access-Client-Secret": os.environ.get("CLOUDFLARE_ACCESS_CLIENT_SECRET", ""),
+    }
+    if not all(headers.values()):
+        raise ApiError("set CLOUDFLARE_ACCESS_CLIENT_ID and CLOUDFLARE_ACCESS_CLIENT_SECRET")
+    return call(method, "/admin" + path, body, headers=headers)

pokerbots_dev-0.1.0/src/pokerbots_cli/auth.py

@@ -0,0 +1,61 @@
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+import webbrowser
+from pathlib import Path
+
+CLIENT_ID = "Ov23li6ejCOkXTqOb0SW"
+DEVICE_URL = "https://github.com/login/device/code"
+TOKEN_URL = "https://github.com/login/oauth/access_token"
+USER_URL = "https://api.github.com/user"
+
+
+def credentials_path():
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "pokerbots" / "credentials.json"
+
+
+def save(credentials):
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch(mode=0o600, exist_ok=True)
+    path.write_text(json.dumps(credentials))
+
+
+def load():
+    path = credentials_path()
+    return json.loads(path.read_text()) if path.exists() else None
+
+
+def request(url, data=None, token=None):
+    headers = {"Accept": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    body = urllib.parse.urlencode(data).encode() if data else None
+    with urllib.request.urlopen(urllib.request.Request(url, body, headers)) as response:
+        return json.load(response)
+
+
+def login(out=print):
+    device = request(DEVICE_URL, {"client_id": CLIENT_ID})
+    out(f"open  {device['verification_uri']}\ncode  {device['user_code']}")
+    webbrowser.open(device["verification_uri"])
+    interval = device["interval"]
+    deadline = time.monotonic() + device["expires_in"]
+    while time.monotonic() < deadline:
+        time.sleep(interval)
+        reply = request(TOKEN_URL, {
+            "client_id": CLIENT_ID,
+            "device_code": device["device_code"],
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+        })
+        if "access_token" in reply:
+            user = request(USER_URL, token=reply["access_token"])["login"]
+            save({"github_token": reply["access_token"], "user": user})
+            return user
+        if reply.get("error") == "slow_down":
+            interval = reply.get("interval", interval + 5)
+        elif reply.get("error") != "authorization_pending":
+            raise RuntimeError(reply.get("error_description") or reply.get("error"))
+    raise RuntimeError("code expired")

pokerbots_dev-0.1.0/src/pokerbots_cli/cards.py

@@ -0,0 +1,41 @@
+from collections import Counter
+from itertools import combinations
+
+RANKS = "23456789TJQKA"
+SUITS = "cdhs"
+DECK = tuple(r + s for r in RANKS for s in SUITS)
+
+
+def rank5(cards):
+    values = sorted((RANKS.index(c[0]) for c in cards), reverse=True)
+    counts = Counter(values)
+    ordered = sorted(counts, key=lambda v: (counts[v], v), reverse=True)
+    shape = sorted(counts.values(), reverse=True)
+    flush = len({c[1] for c in cards}) == 1
+    straight = None
+    if len(counts) == 5:
+        if values[0] - values[4] == 4:
+            straight = values[0]
+        elif values == [12, 3, 2, 1, 0]:
+            straight = 3
+    if straight is not None and flush:
+        return (8, straight)
+    if shape[0] == 4:
+        return (7, *ordered)
+    if shape == [3, 2]:
+        return (6, *ordered)
+    if flush:
+        return (5, *values)
+    if straight is not None:
+        return (4, straight)
+    if shape[0] == 3:
+        return (3, *ordered)
+    if shape == [2, 2, 1]:
+        return (2, *ordered)
+    if shape[0] == 2:
+        return (1, *ordered)
+    return (0, *values)
+
+
+def best(cards):
+    return max(rank5(five) for five in combinations(cards, 5))

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

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

pokerbots_dev-0.1.0/src/pokerbots_cli/commands/account.py

@@ -0,0 +1,89 @@
+import io
+import sys
+import zipfile
+from pathlib import Path
+
+from .. import auth
+from ..api import call
+from ..fmt import money, place, table
+
+MAX_UPLOAD = 1 << 20
+ATTEST = "I am 18 or older, and paid skill competitions are allowed where I am. [y/N] "
+
+
+def login(args):
+    try:
+        print(f"logged in as {auth.login()}")
+    except (RuntimeError, OSError) as e:
+        sys.exit(f"login failed: {e}")
+
+
+def bundle(directory):
+    root = Path(directory)
+    if not (root / "bot.py").exists():
+        sys.exit(f"no bot.py in {directory}")
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as z:
+        for path in sorted(root.rglob("*")):
+            relative = path.relative_to(root)
+            if path.is_file() and not any(p.startswith(".") or p == "__pycache__" for p in relative.parts):
+                z.write(path, relative.as_posix())
+    if buffer.tell() > MAX_UPLOAD:
+        sys.exit("bot is over 1 MB zipped")
+    return buffer.getvalue()
+
+
+def upload(args):
+    reply = call("POST", "/versions", data=bundle(args.dir), headers={"Content-Type": "application/zip"})
+    print(f"uploaded v{reply['version']}")
+
+
+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":
+            sys.exit("not deployed")
+        call("POST", "/attest")
+    call("POST", "/deployments", {"mode": mode, "version": int(args.version.lstrip("v"))})
+    print(f"{args.version} deployed {mode}")
+
+
+def stop(args):
+    mode = "live" if args.live else "paper"
+    call("DELETE", f"/deployments/{mode}")
+    print(f"stopped {mode}")
+
+
+def status(args):
+    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 "-"]]
+    print(table(rows))
+    games = call("GET", "/games")
+    if games:
+        print()
+        print(table([["game", "mode", "place", "hands"]] + [
+            [g["created_at"], g["mode"], place(g["place"]), g["hands"] or "-"] for g in games
+        ]))
+
+
+def register(sub):
+    sub.add_parser("login", help="sign in with GitHub").set_defaults(run=login)
+
+    p = sub.add_parser("upload", help="upload a new version")
+    p.add_argument("dir", nargs="?", default=".")
+    p.set_defaults(run=upload)
+
+    for name, run, help in (("deploy", deploy, "play a version"), ("stop", stop, "stop playing")):
+        p = sub.add_parser(name, help=help)
+        if name == "deploy":
+            p.add_argument("version", help="e.g. v1")
+        mode = p.add_mutually_exclusive_group(required=True)
+        mode.add_argument("--paper", action="store_true")
+        mode.add_argument("--live", action="store_true")
+        p.set_defaults(run=run)
+
+    sub.add_parser("status", help="your bot, rating, balance and recent games").set_defaults(run=status)

pokerbots_dev-0.1.0/src/pokerbots_cli/commands/admin.py

@@ -0,0 +1,36 @@
+from ..api import admin
+from ..fmt import money, table
+
+
+def stats(args):
+    s = admin("GET", "/stats")
+    print(table([
+        ["users", s["users"]],
+        ["games today", s["games_today"]],
+        ["owed to users", money(s["liabilities"])],
+        ["hot wallet", f"{money(s['hot_usdc'])} USDC, {s['hot_sol']} SOL"],
+        ["withdrawn today", money(s["withdrawn_today"])],
+    ]))
+
+
+def withdrawals(args):
+    rows = admin("GET", "/withdrawals")
+    print(table([["id", "user", "amount", "requested"]] + [
+        [w["id"], w["login"], money(w["amount"]), w["created_at"]] for w in rows
+    ]) if rows else "no pending withdrawals")
+
+
+def decide(args):
+    reply = admin("POST", f"/withdrawals/{args.id}", {"action": args.action})
+    print(f"{args.id} {reply['status']}")
+
+
+def register(sub):
+    p = sub.add_parser("admin", help="operator commands")
+    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)
+    for action in ("approve", "reject"):
+        q = admin_sub.add_parser(action)
+        q.add_argument("id")
+        q.set_defaults(run=decide, action=action)

pokerbots_dev-0.1.0/src/pokerbots_cli/commands/local.py

@@ -0,0 +1,83 @@
+import importlib.util
+import pydoc
+import random
+import shutil
+import sys
+from importlib import resources
+from pathlib import Path
+
+from .. import engine
+from ..agent import Agent
+from ..fmt import table
+from ..house import BOTS
+
+PACKAGE = resources.files("pokerbots_cli")
+
+
+def docs(args):
+    text = PACKAGE.joinpath("docs.md").read_text()
+    if args.plain or not sys.stdout.isatty():
+        print(text, end="")
+    else:
+        pydoc.pager(text)
+
+
+def init(args):
+    path = Path(args.name)
+    if path.exists():
+        sys.exit(f"{path} already exists")
+    path.mkdir(parents=True)
+    shutil.copy(PACKAGE.joinpath("template", "bot.py"), path / "bot.py")
+    print(f"created {path / 'bot.py'}")
+
+
+def load_bot(directory):
+    path = Path(directory) / "bot.py"
+    if not path.exists():
+        sys.exit(f"no bot.py in {directory}")
+    sys.path.insert(0, str(path.parent.resolve()))
+    spec = importlib.util.spec_from_file_location("bot", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.Bot
+
+
+def test(args):
+    Bot = load_bot(args.dir)
+    rng = random.Random(args.seed)
+    mine = Agent(None)
+    places = []
+    for _ in range(args.games):
+        mine.bot = Bot()
+        agents = [mine] + [Agent(cls()) for cls in BOTS]
+        rng.shuffle(agents)
+        places.append(engine.play(agents, rng).places.index(agents.index(mine)) + 1)
+    print(table([
+        ["games", args.games],
+        ["1st", places.count(1)],
+        ["2nd", places.count(2)],
+        ["avg place", f"{sum(places) / len(places):.1f}"],
+        ["decisions", mine.decisions],
+        ["over 20 ms", mine.late],
+        ["errors", mine.errors],
+        ["slowest", f"{mine.slowest * 1000:.2f} ms"],
+    ]))
+    if mine.error:
+        print(f"\nfirst error\n{mine.error}")
+        return 1
+
+
+def register(sub):
+    p = sub.add_parser("docs", help="show the docs")
+    p.add_argument("--plain", action="store_true", help="no pager, for agents")
+    p.set_defaults(run=docs)
+
+    p = sub.add_parser("init", help="create a bot")
+    p.add_argument("name")
+    p.set_defaults(run=init)
+
+    p = sub.add_parser("test", help="play local games against house bots")
+    p.add_argument("dir", nargs="?", default=".")
+    p.add_argument("--games", type=int, default=100)
+    p.add_argument("--seed", type=int)
+    p.set_defaults(run=test)

pokerbots_dev-0.1.0/src/pokerbots_cli/commands/money.py

@@ -0,0 +1,37 @@
+from .. import wallet as keys
+from ..api import call
+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:
+        call("PUT", "/wallet", {"address": address})
+    return key, address
+
+
+def wallet(args):
+    _, address = registered_key()
+    print(table([["address", address], ["balance", money(call("GET", "/me")["balance"])]]))
+
+
+def deposit(args):
+    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()
+    reply = call("POST", "/withdrawals", {"amount": parse_money(args.amount)})
+    print(f"withdrawal {reply['status']}: {money(reply['amount'])}")
+
+
+def register(sub):
+    sub.add_parser("wallet", help="your Solana wallet address and balance").set_defaults(run=wallet)
+    for name, run in (("deposit", deposit), ("withdraw", withdraw)):
+        p = sub.add_parser(name, help=f"{name} USDC, e.g. pb {name} 5")
+        p.add_argument("amount", help="dollars")
+        p.set_defaults(run=run)

pokerbots_dev-0.1.0/src/pokerbots_cli/docs.md

@@ -0,0 +1,91 @@
+pokerbots.dev
+
+start
+  pb login                   sign in with GitHub
+  pb init mybot              create mybot/bot.py
+  pb test [dir]              play 100 local games against house bots
+  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 status                  versions, rating, balance, recent games
+  pb docs [--plain]          show this
+
+money
+  pb wallet                  your Solana wallet address and balance
+  pb deposit 5               move $5 USDC from your wallet to your balance
+  pb withdraw 5              move $5 back to your wallet
+
+  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.
+
+bot.py
+  class Bot:
+      def act(self, state):
+          if "check" in state["legal"]:
+              return ("check",)
+          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,
+  up to 1 MB zipped. Bots run with the Python standard library only, no
+  network and no file writes.
+
+actions
+  ("fold",)
+  ("check",)
+  ("call",)
+  ("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
+  stacks       chips behind, by seat
+  bets         chips bet this round, by seat
+  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
+  actions      this hand so far, [cards on board, seat, action, bet this round]
+
+cards
+  ranks  23456789TJQKA
+  suits  cdhs
+
+game
+  no-limit hold'em sit-and-go
+  6 bots, new random table every game
+  1,000 chips each
+  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
+  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
+
+price
+  paper   free, 1,000 games/day
+
+  live*   buy-in   10¢
+          pot      60¢
+          1st      37¢
+          2nd      20¢
+          paid in  USDC on Solana
+
+  * 18+, and only where paid skill competitions are allowed for you.
+    deposits are held in our Solana wallets and tracked by us until you
+    withdraw.
+
+contact
+  hello@pokerbots.dev

pokerbots_dev-0.1.0/src/pokerbots_cli/engine.py

@@ -0,0 +1,151 @@
+import random
+from dataclasses import dataclass
+
+from .cards import DECK, best
+
+STACK = 1000
+MAX_HANDS = 100
+
+
+@dataclass
+class Player:
+    seat: int
+    agent: object
+    stack: int = STACK
+    hole: tuple = ()
+    bet: int = 0
+    committed: int = 0
+    folded: bool = False
+
+    @property
+    def can_act(self):
+        return not self.folded and self.stack > 0
+
+    def put(self, chips):
+        chips = min(chips, self.stack)
+        self.stack -= chips
+        self.bet += chips
+        self.committed += chips
+
+
+@dataclass
+class Result:
+    places: list
+    hands: int
+    stacks: list
+
+
+class Hand:
+    def __init__(self, number, players, button, deck, seats):
+        self.number = number
+        self.players = players
+        self.button = button
+        self.deck = deck
+        self.seats = seats
+        self.blinds = [number, 2 * number]
+        self.board = []
+        self.log = []
+
+    def play(self):
+        n = len(self.players)
+        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
+        for i, blind in zip((small, (small + 1) % n), self.blinds):
+            self.players[i].put(blind)
+            self.record(self.players[i], "blind")
+        self.betting((small + 2) % n, self.blinds[1])
+        for count in (3, 1, 1):
+            if sum(not p.folded for p in self.players) < 2:
+                break
+            for p in self.players:
+                p.bet = 0
+            self.board += [self.deck.pop() for _ in range(count)]
+            self.betting((self.button + 1) % n, 0)
+        self.award()
+
+    def betting(self, start, current):
+        order = self.players[start:] + self.players[:start]
+        queue = [p for p in order if p.can_act]
+        step = self.blinds[1]
+        while queue and sum(not p.folded for p in self.players) > 1:
+            p = queue.pop(0)
+            others = any(q.can_act for q in self.players if q is not p)
+            if not p.can_act or (p.bet >= current and not others):
+                continue
+            to_call = current - p.bet
+            legal = ["fold", "call"] if to_call > 0 else ["check"]
+            state = self.state(p, legal, to_call)
+            if others and p.stack > to_call:
+                legal.append("raise")
+                state["max_raise"] = p.bet + p.stack
+                state["min_raise"] = min(current + step, state["max_raise"])
+            action = p.agent(state)
+            if action[0] == "fold":
+                p.folded = True
+            elif action[0] == "call":
+                p.put(to_call)
+            elif action[0] == "raise":
+                p.put(action[1] - p.bet)
+                step = max(step, p.bet - current)
+                current = max(current, p.bet)
+                i = order.index(p)
+                queue = [q for q in order[i + 1:] + order[:i] if q.can_act]
+            self.record(p, action[0])
+
+    def record(self, p, action):
+        self.log.append([len(self.board), p.seat, action, p.bet])
+
+    def state(self, p, legal, to_call):
+        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,
+            "seat": p.seat,
+            "button": self.players[self.button].seat,
+            "blinds": list(self.blinds),
+            "hole": list(p.hole),
+            "board": list(self.board),
+            "stacks": stacks,
+            "bets": bets,
+            "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],
+            "actions": [list(a) for a in self.log],
+        }
+
+    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 {}
+        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]
+            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)
+
+
+def play(agents, rng=None, max_hands=MAX_HANDS):
+    rng = rng or random.Random()
+    table = [Player(seat, agent) for seat, agent in enumerate(agents)]
+    busted = []
+    button = rng.randrange(len(table))
+    hands = 0
+    while hands < max_hands and sum(p.stack > 0 for p in table) > 1:
+        hands += 1
+        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)
+        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])

pokerbots_dev-0.1.0/src/pokerbots_cli/fmt.py

@@ -0,0 +1,23 @@
+MICRO = 1_000_000
+
+
+def table(rows):
+    rows = [[str(c) for c in row] for row in rows]
+    widths = [max(len(r[i]) for r in rows if i < len(r)) for i in range(max(map(len, rows)))]
+    return "\n".join("  ".join(c.ljust(w) for c, w in zip(r, widths)).rstrip() for r in rows)
+
+
+def money(micro):
+    cents = round(micro / 10_000)
+    return f"{cents}¢" if abs(cents) < 100 else f"${cents / 100:,.2f}"
+
+
+def parse_money(text):
+    value = round(float(text.lstrip("$")) * MICRO)
+    if value <= 0:
+        raise ValueError("amount must be positive")
+    return value
+
+
+def place(n):
+    return {1: "1st", 2: "2nd", 3: "3rd"}.get(n, f"{n}th") if n else "-"

pokerbots_dev-0.1.0/src/pokerbots_cli/house.py

@@ -0,0 +1,19 @@
+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.0/src/pokerbots_cli/main.py

@@ -0,0 +1,31 @@
+import argparse
+import sys
+
+from pokerbots_cli import __version__
+from pokerbots_cli.api import ApiError
+from pokerbots_cli.commands import MODULES
+
+
+def parser():
+    p = argparse.ArgumentParser(prog="pb", description="pokerbots.dev")
+    p.add_argument("--version", action="version", version=f"pb {__version__}")
+    sub = p.add_subparsers(metavar="command")
+    for module in MODULES:
+        module.register(sub)
+    return p
+
+
+def main(argv=None):
+    p = parser()
+    args = p.parse_args(argv)
+    if not hasattr(args, "run"):
+        p.print_help()
+        return 0
+    try:
+        return args.run(args) or 0
+    except (ApiError, ValueError) as e:
+        sys.exit(f"error: {e}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pokerbots_dev-0.1.0/src/pokerbots_cli/template/bot.py

@@ -0,0 +1,5 @@
+class Bot:
+    def act(self, state):
+        if "check" in state["legal"]:
+            return ("check",)
+        return ("fold",)

pokerbots_dev-0.1.0/src/pokerbots_cli/wallet.py

@@ -0,0 +1,67 @@
+import base64
+import json
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+
+from .auth import credentials_path
+
+ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def b58(data):
+    n = int.from_bytes(data, "big")
+    out = ""
+    while n:
+        n, r = divmod(n, 58)
+        out = ALPHABET[r] + out
+    return "1" * (len(data) - len(data.lstrip(b"\0"))) + out
+
+
+def path():
+    return credentials_path().with_name("wallet.json")
+
+
+def public(key):
+    return key.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)
+
+
+def load_or_create():
+    """Solana keypair file format: JSON array of 64 bytes, secret seed then public key."""
+    p = path()
+    if p.exists():
+        return Ed25519PrivateKey.from_private_bytes(bytes(json.loads(p.read_text())[:32]))
+    key = Ed25519PrivateKey.generate()
+    seed = key.private_bytes_raw()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.touch(mode=0o600)
+    p.write_text(json.dumps(list(seed + public(key))))
+    return key
+
+
+def address(key):
+    return b58(public(key))
+
+
+def shortvec(data, i):
+    value = shift = 0
+    while True:
+        byte = data[i]
+        i += 1
+        value |= (byte & 0x7F) << shift
+        shift += 7
+        if byte < 0x80:
+            return value, i
+
+
+def sign(transaction_b64, key):
+    """Adds our signature to a partially signed wire transaction."""
+    wire = base64.b64decode(transaction_b64)
+    count, start = shortvec(wire, 0)
+    message = wire[start + 64 * count:]
+    versioned = message[0] & 0x80
+    signers = message[1 if versioned else 0]
+    _, offset = shortvec(message, (1 if versioned else 0) + 3)
+    keys = [message[offset + 32 * i: offset + 32 * (i + 1)] for i in range(signers)]
+    at = start + 64 * keys.index(public(key))
+    return base64.b64encode(wire[:at] + key.sign(message) + wire[at + 64:]).decode()

pokerbots_dev-0.1.0/tests/test_agent.py

@@ -0,0 +1,33 @@
+import time
+
+from pokerbots_cli.agent import Agent
+
+STATE = {"legal": ["fold", "call", "raise"], "min_raise": 40, "max_raise": 500}
+
+
+class Fixed:
+    def __init__(self, reply):
+        self.reply = reply
+
+    def act(self, state):
+        return self.reply(state)
+
+
+def run(reply):
+    agent = Agent(Fixed(reply))
+    return agent(dict(STATE)), agent
+
+
+def test_legal_actions_pass_and_raises_clamp():
+    assert run(lambda s: ("call",))[0] == ("call",)
+    assert run(lambda s: ("raise", 10_000))[0] == ("raise", 500)
+    assert run(lambda s: ("raise", 1))[0] == ("raise", 40)
+
+
+def test_bad_bots_fold():
+    action, agent = run(lambda s: time.sleep(0.03))
+    assert action == ("fold",) and agent.late == 1
+    action, agent = run(lambda s: 1 / 0)
+    assert action == ("fold",) and "ZeroDivisionError" in agent.error
+    action, agent = run(lambda s: ("check",))
+    assert action == ("fold",) and agent.errors == 1

pokerbots_dev-0.1.0/tests/test_cards.py

@@ -0,0 +1,27 @@
+from pokerbots_cli.cards import best
+
+
+def hand(text):
+    return best(text.split())
+
+
+def test_categories_ordered():
+    ladder = [
+        "2c 7d 9h Js Kc 3d 4h",  # high card
+        "2c 2d 9h Js Kc 3d 4h",  # pair
+        "2c 2d 9h 9s Kc 3d 4h",  # two pair
+        "2c 2d 2h Js Kc 3d 4h",  # trips
+        "Ac 2d 3h 4s 5c 9d Jh",  # wheel
+        "6c 2d 3h 4s 5c 9d Jh",  # six-high straight
+        "2c 7c 9c Jc Kc 3d 4h",  # flush
+        "2c 2d 2h Js Jc 3d 4h",  # full house
+        "2c 2d 2h 2s Kc 3d 4h",  # quads
+        "Ac 2c 3c 4c 5c 9d Jh",  # steel wheel
+    ]
+    ranks = [hand(h) for h in ladder]
+    assert ranks == sorted(ranks) and len(set(ranks)) == len(ranks)
+
+
+def test_kicker_and_board_play():
+    assert hand("As Kd 7c 7d 9h Js 2c") > hand("As Qd 7c 7d 9h Js 2c")
+    assert hand("2s 3d Ac Kc Qc Jc Tc") == hand("4s 5d Ac Kc Qc Jc Tc")

pokerbots_dev-0.1.0/tests/test_cli.py

@@ -0,0 +1,22 @@
+import pytest
+
+from pokerbots_cli.main import main
+
+
+def test_version(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["--version"])
+    assert exc.value.code == 0
+    assert capsys.readouterr().out.startswith("pb ")
+
+
+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
+
+
+def test_docs_plain(capsys):
+    assert main(["docs", "--plain"]) == 0
+    assert "min_raise" in capsys.readouterr().out

pokerbots_dev-0.1.0/tests/test_engine.py

@@ -0,0 +1,36 @@
+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]

pokerbots_dev-0.1.0/tests/test_wallet.py

@@ -0,0 +1,24 @@
+import base64
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+from pokerbots_cli import wallet
+from pokerbots_cli.fmt import money, parse_money
+
+
+def test_sign_fills_our_slot_only():
+    payer, me = Ed25519PrivateKey.generate(), Ed25519PrivateKey.generate()
+    message = bytes([0x80, 2, 0, 1, 3]) + wallet.public(payer) + wallet.public(me) + bytes(32) + bytes(40)
+    payer_signature = payer.sign(message)
+    wire = bytes([2]) + payer_signature + bytes(64) + message
+    signed = base64.b64decode(wallet.sign(base64.b64encode(wire).decode(), me))
+    assert signed[1:65] == payer_signature
+    me.public_key().verify(signed[65:129], message)
+    assert signed[129:] == message
+
+
+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 parse_money("$0.10") == 100_000

pokerbots_dev-0.0.1/src/pokerbots_cli/main.py

@@ -1,15 +0,0 @@
-import argparse
-
-from pokerbots_cli import __version__
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(prog="pb", description="pokerbots.dev command-line client")
-    parser.add_argument("--version", action="version", version=f"pb {__version__}")
-    parser.parse_args(argv)
-    parser.print_help()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

pokerbots_dev-0.0.1/tests/test_cli.py

@@ -1,15 +0,0 @@
-import pytest
-
-from pokerbots_cli.main import main
-
-
-def test_version(capsys):
-    with pytest.raises(SystemExit) as exc:
-        main(["--version"])
-    assert exc.value.code == 0
-    assert capsys.readouterr().out.startswith("pb ")
-
-
-def test_no_args_prints_help(capsys):
-    assert main([]) == 0
-    assert "usage: pb" in capsys.readouterr().out