screenstocks-bridge 0.2.0__tar.gz

screenstocks_bridge-0.2.0/LICENSE

@@ -0,0 +1,7 @@
+MIT No Attribution
+
+Copyright 2026 fuubox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

screenstocks_bridge-0.2.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: screenstocks-bridge
+Version: 0.2.0
+Summary: Python client for the local Screen Stocks BepInEx bridge
+License-Expression: MIT-0
+Project-URL: Homepage, https://github.com/fuubox/screen-stocks-bridge
+Project-URL: Documentation, https://github.com/fuubox/screen-stocks-bridge#readme
+Project-URL: Repository, https://github.com/fuubox/screen-stocks-bridge
+Project-URL: Issues, https://github.com/fuubox/screen-stocks-bridge/issues
+Keywords: screen-stocks,bepinex,game-modding,bridge
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Screen Stocks Python Bridge
+
+The `screenstocks-bridge` package is a Python client for the local API exposed
+by the Screen Stocks Bridge BepInEx plugin. It requires the plugin to be
+installed in the game and the game to be running. The package itself does not
+install or contact the game backend; it connects to the plugin on loopback.
+
+## Install
+
+```powershell
+python -m pip install screenstocks-bridge
+```
+
+Install the matching BepInEx plugin from the
+[GitHub releases](https://github.com/fuubox/screen-stocks-bridge/releases),
+then launch Screen Stocks. The default bridge address is `127.0.0.1:48721`.
+Read the token from `BepInEx/config/screenstocks.bridge.cfg` or the BepInEx
+log.
+
+## Connect
+
+```python
+from screenstocks_bridge import BridgeClient
+
+with BridgeClient(token="YOUR_TOKEN") as bridge:
+    state = bridge.snapshot()
+    print(state["ready"], state["cash"])
+    print(bridge.upgrades())
+```
+
+The client supports state and activity reads, trades, upgrade purchases, and
+auto-action controls. See the
+[bridge usage guide](https://github.com/fuubox/screen-stocks-bridge/blob/main/docs/bridge-usage.md)
+for the full API and its online behavior.

screenstocks_bridge-0.2.0/README.md

@@ -0,0 +1,34 @@
+# Screen Stocks Python Bridge
+
+The `screenstocks-bridge` package is a Python client for the local API exposed
+by the Screen Stocks Bridge BepInEx plugin. It requires the plugin to be
+installed in the game and the game to be running. The package itself does not
+install or contact the game backend; it connects to the plugin on loopback.
+
+## Install
+
+```powershell
+python -m pip install screenstocks-bridge
+```
+
+Install the matching BepInEx plugin from the
+[GitHub releases](https://github.com/fuubox/screen-stocks-bridge/releases),
+then launch Screen Stocks. The default bridge address is `127.0.0.1:48721`.
+Read the token from `BepInEx/config/screenstocks.bridge.cfg` or the BepInEx
+log.
+
+## Connect
+
+```python
+from screenstocks_bridge import BridgeClient
+
+with BridgeClient(token="YOUR_TOKEN") as bridge:
+    state = bridge.snapshot()
+    print(state["ready"], state["cash"])
+    print(bridge.upgrades())
+```
+
+The client supports state and activity reads, trades, upgrade purchases, and
+auto-action controls. See the
+[bridge usage guide](https://github.com/fuubox/screen-stocks-bridge/blob/main/docs/bridge-usage.md)
+for the full API and its online behavior.

screenstocks_bridge-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "screenstocks-bridge"
+version = "0.2.0"
+description = "Python client for the local Screen Stocks BepInEx bridge"
+readme = "README.md"
+license = "MIT-0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["screen-stocks", "bepinex", "game-modding", "bridge"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/fuubox/screen-stocks-bridge"
+Documentation = "https://github.com/fuubox/screen-stocks-bridge#readme"
+Repository = "https://github.com/fuubox/screen-stocks-bridge"
+Issues = "https://github.com/fuubox/screen-stocks-bridge/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

screenstocks_bridge-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

screenstocks_bridge-0.2.0/src/screenstocks_bridge/__init__.py

@@ -0,0 +1,8 @@
+"""Python client for the local Screen Stocks BepInEx bridge."""
+
+from .client import BridgeClient
+from .models import AutoAction, AutoActions, Cooldown, HumanActivity, HumanActivityPage, Position, Snapshot, Stock, TradeCooldowns, TradeReceipt
+from .protocol import BridgeError
+
+__all__ = ["AutoAction", "AutoActions", "BridgeClient", "BridgeError", "Cooldown", "HumanActivity", "HumanActivityPage", "Position",
+           "Snapshot", "Stock", "TradeCooldowns", "TradeReceipt"]

screenstocks_bridge-0.2.0/src/screenstocks_bridge/client.py

@@ -0,0 +1,272 @@
+"""Thread-safe JSON-lines client for the local Screen Stocks bridge."""
+
+from __future__ import annotations
+
+import json
+import queue
+import socket
+import threading
+import uuid
+from collections.abc import Callable
+from typing import Any
+
+from .protocol import MAX_FRAME_BYTES, BridgeError, _ReaderStopped
+
+
+class BridgeClient:
+    """Connect to the in-game loopback bridge and issue state or trade calls."""
+
+    def __init__(self, host: str = "127.0.0.1", port: int = 48721,
+                 token: str = "", timeout: float = 5.0) -> None:
+        self.host = host
+        self.port = port
+        self.token = token
+        self.timeout = timeout
+        self._socket: socket.socket | None = None
+        self._send_lock = threading.Lock()
+        self._pending_lock = threading.Lock()
+        self._pending: dict[str, queue.Queue[dict[str, Any] | BaseException]] = {}
+        self._callbacks_lock = threading.Lock()
+        self._callbacks: list[Callable[[dict[str, Any]], None]] = []
+        self._events: queue.Queue[dict[str, Any] | None] = queue.Queue(maxsize=128)
+        self._trade_events: queue.Queue[dict[str, Any] | None] = queue.Queue(maxsize=128)
+        self._closed = threading.Event()
+        self._reader: threading.Thread | None = None
+        self._event_worker: threading.Thread | None = None
+
+    def connect(self) -> BridgeClient:
+        """Open the authenticated TCP connection. Returns this client."""
+        if self._socket is not None:
+            return self
+        if not self.token:
+            raise ValueError("A bridge token is required.")
+        sock = socket.create_connection((self.host, self.port), timeout=self.timeout)
+        sock.settimeout(None)
+        self._socket = sock
+        self._closed.clear()
+        self._reader = threading.Thread(target=self._read_loop, name="screenstocks-reader", daemon=True)
+        self._event_worker = threading.Thread(target=self._event_loop, name="screenstocks-events", daemon=True)
+        self._reader.start()
+        self._event_worker.start()
+        return self
+
+    def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Send an RPC call and return its result object."""
+        if self._socket is None or self._closed.is_set():
+            raise BridgeError("not_connected", "Call connect() before making a request.")
+        request_id = uuid.uuid4().hex
+        waiter: queue.Queue[dict[str, Any] | BaseException] = queue.Queue(maxsize=1)
+        with self._pending_lock:
+            self._pending[request_id] = waiter
+        frame = {
+            "id": request_id,
+            "method": method,
+            "token": self.token,
+            "params": params or {},
+        }
+        try:
+            encoded = (json.dumps(frame, separators=(",", ":"), allow_nan=False) + "\n").encode("utf-8")
+            if len(encoded) - 1 > MAX_FRAME_BYTES:
+                raise BridgeError("frame_too_large", "Request exceeds the 16 KiB frame limit.")
+            with self._send_lock:
+                if self._closed.is_set() or self._socket is None:
+                    raise BridgeError("not_connected", "The bridge connection is closed.")
+                self._socket.sendall(encoded)
+            try:
+                response = waiter.get(timeout=self.timeout)
+            except queue.Empty as exc:
+                raise BridgeError("timeout", "The bridge did not answer before the request timeout.") from exc
+            if isinstance(response, BaseException):
+                raise BridgeError("disconnected", str(response)) from response
+            if not response.get("ok"):
+                error = response.get("error") or {}
+                raise BridgeError(str(error.get("code", "remote_error")), str(error.get("message", "Bridge request failed.")))
+            result = response.get("result")
+            return result if isinstance(result, dict) else {}
+        finally:
+            with self._pending_lock:
+                self._pending.pop(request_id, None)
+
+    def snapshot(self) -> dict[str, Any]:
+        """Return the current in-memory player and visible-market snapshot."""
+        return self.request("state.snapshot")
+
+    def human_activity(self, stock_id: str, limit: int = 32,
+                       before_tick: int | None = None) -> dict[str, Any]:
+        """Return one page of aggregate graph activity for a visible stock."""
+        params: dict[str, Any] = {"stockId": stock_id, "limit": limit}
+        if before_tick is not None:
+            params["beforeTick"] = before_tick
+        return self.request("market.human_activity", params)
+
+    def subscribe_market(self, callback: Callable[[dict[str, Any]], None]) -> None:
+        """Subscribe to market.updated and trade.completed event dictionaries."""
+        with self._callbacks_lock:
+            if callback not in self._callbacks:
+                self._callbacks.append(callback)
+        self.request("state.subscribe")
+
+    def trade(self, action: str, stock_id: str, percent: float | None = None) -> dict[str, Any]:
+        """Submit one explicit allowlisted trade; completion arrives as an event."""
+        params: dict[str, Any] = {"action": action, "stockId": stock_id}
+        if percent is not None:
+            params["percent"] = percent
+        return self.request("trade.submit", params)
+
+    def upgrades(self) -> dict[str, Any]:
+        """Return the game's dynamically discovered upgrade catalog and current levels."""
+        return self.request("upgrades.snapshot")
+
+    def purchase_upgrade(self, upgrade_id: str, quantity: int = 1) -> dict[str, Any]:
+        """Ask the running game to process an upgrade through its in-process method.
+
+        The bridge itself only talks to localhost. The game may communicate with its
+        server in online mode; server state remains authoritative. The returned status
+        is ``submitted``.
+        Refresh :meth:`upgrades` to observe the resulting level.
+        """
+        return self.request("upgrades.purchase", {"upgradeId": upgrade_id, "quantity": quantity})
+
+    def auto_actions(self) -> dict[str, Any]:
+        """Return dynamically discovered auto-action slots and cooldown state."""
+        return self.request("auto_actions.snapshot")
+
+    def add_auto_action(self, stock_id: str, action_type: str, condition: str,
+                        target_price: float, amount_percentage: int) -> dict[str, Any]:
+        """Add an auto action in an available game slot and return its slot index."""
+        return self.request("auto_actions.add", {
+            "stockId": stock_id, "actionType": action_type, "condition": condition,
+            "targetPrice": target_price, "amountPercentage": amount_percentage,
+        })
+
+    def update_auto_action(self, slot_index: int, stock_id: str, action_type: str,
+                           condition: str, target_price: float,
+                           amount_percentage: int) -> dict[str, Any]:
+        """Replace an auto action's complete configuration by its discovered slot index."""
+        return self.request("auto_actions.update", {
+            "slotIndex": slot_index, "stockId": stock_id, "actionType": action_type,
+            "condition": condition, "targetPrice": target_price,
+            "amountPercentage": amount_percentage,
+        })
+
+    def remove_auto_action(self, slot_index: int) -> dict[str, Any]:
+        """Remove the configured auto action occupying slot_index."""
+        return self.request("auto_actions.remove", {"slotIndex": slot_index})
+
+    def set_auto_action_enabled(self, slot_index: int, enabled: bool) -> dict[str, Any]:
+        """Enable or disable one configured auto action."""
+        return self.request("auto_actions.set_enabled", {"slotIndex": slot_index, "enabled": enabled})
+
+    def set_auto_actions_active(self, active: bool) -> dict[str, Any]:
+        """Set the game's global auto-action switch."""
+        return self.request("auto_actions.set_active", {"active": active})
+
+    def close(self) -> None:
+        """Close the socket and stop its reader and event worker threads."""
+        self._fail_pending(_ReaderStopped("Client closed."))
+        self._closed.set()
+        sock, self._socket = self._socket, None
+        if sock is not None:
+            try:
+                sock.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
+            try:
+                sock.close()
+            except OSError:
+                pass
+        try:
+            self._events.put_nowait(None)
+        except queue.Full:
+            pass
+        try:
+            self._trade_events.put_nowait(None)
+        except queue.Full:
+            pass
+
+    def _read_loop(self) -> None:
+        buffer = bytearray()
+        sock = self._socket
+        try:
+            if sock is None:
+                return
+            while not self._closed.is_set():
+                chunk = sock.recv(4096)
+                if not chunk:
+                    raise _ReaderStopped("Bridge closed the connection.")
+                buffer.extend(chunk)
+                while True:
+                    newline = buffer.find(b"\n")
+                    if newline < 0:
+                        if len(buffer) > MAX_FRAME_BYTES:
+                            raise BridgeError("frame_too_large", "Bridge response exceeds the 16 KiB frame limit.")
+                        break
+                    if newline > MAX_FRAME_BYTES:
+                        raise BridgeError("frame_too_large", "Bridge response exceeds the 16 KiB frame limit.")
+                    raw = bytes(buffer[:newline]).rstrip(b"\r")
+                    del buffer[:newline + 1]
+                    message = json.loads(raw.decode("utf-8"))
+                    if "event" in message:
+                        self._queue_event(message)
+                    else:
+                        with self._pending_lock:
+                            waiter = self._pending.get(str(message.get("id", "")))
+                        if waiter is not None:
+                            waiter.put(message)
+        except BaseException as exc:
+            if not self._closed.is_set():
+                self._fail_pending(exc)
+                self._closed.set()
+
+    def _queue_event(self, event: dict[str, Any]) -> None:
+        if event.get("event") == "trade.completed":
+            # Preserve trade outcomes; a full completion queue applies TCP backpressure.
+            self._trade_events.put(event)
+            return
+        try:
+            self._events.put_nowait(event)
+        except queue.Full:
+            try:
+                self._events.get_nowait()
+            except queue.Empty:
+                pass
+            try:
+                self._events.put_nowait(event)
+            except queue.Full:
+                pass
+
+    def _event_loop(self) -> None:
+        while True:
+            if self._closed.is_set() and self._events.empty() and self._trade_events.empty():
+                return
+            try:
+                event = self._trade_events.get_nowait()
+            except queue.Empty:
+                try:
+                    event = self._events.get(timeout=0.25)
+                except queue.Empty:
+                    continue
+            if event is None:
+                continue
+            with self._callbacks_lock:
+                callbacks = tuple(self._callbacks)
+            for callback in callbacks:
+                try:
+                    callback(event)
+                except Exception:
+                    continue
+
+    def _fail_pending(self, error: BaseException) -> None:
+        with self._pending_lock:
+            waiters = tuple(self._pending.values())
+        for waiter in waiters:
+            try:
+                waiter.put_nowait(error)
+            except queue.Full:
+                pass
+
+    def __enter__(self) -> BridgeClient:
+        return self.connect()
+
+    def __exit__(self, exc_type: Any, exc: Any, traceback: Any) -> None:
+        self.close()

screenstocks_bridge-0.2.0/src/screenstocks_bridge/models.py

@@ -0,0 +1,188 @@
+"""Optional typed views over bridge dictionaries.
+
+Each model retains its source dictionary as ``raw`` so callers can access fields
+added by later protocol versions without waiting for a client release.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class HumanActivity:
+    sample_tick: int
+    up: int
+    down: int
+    total: int
+    net: int
+    up_impact: float
+    down_impact: float
+    total_impact: float
+    net_impact: float
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> HumanActivity:
+        return cls(int(value.get("sampleTick", 0)), int(value.get("up", 0)),
+                   int(value.get("down", 0)), int(value.get("total", 0)),
+                   int(value.get("net", 0)), float(value.get("upImpact", 0)),
+                   float(value.get("downImpact", 0)), float(value.get("totalImpact", 0)),
+                   float(value.get("netImpact", 0)), value)
+
+
+@dataclass(frozen=True)
+class Stock:
+    stock_id: str
+    name: str
+    price: float
+    unlocked: bool
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> Stock:
+        return cls(str(value.get("stockId", "")), str(value.get("name", "")),
+                   float(value.get("price", 0)), bool(value.get("unlocked", False)),
+                   value)
+
+
+@dataclass(frozen=True)
+class HumanActivityPage:
+    stock_id: str
+    samples: list[HumanActivity]
+    has_more: bool
+    next_before_tick: int
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> HumanActivityPage:
+        return cls(str(value.get("stockId", "")),
+                   [HumanActivity.from_dict(item) for item in value.get("samples", [])],
+                   bool(value.get("hasMore", False)), int(value.get("nextBeforeTick", 0)), value)
+
+
+@dataclass(frozen=True)
+class Position:
+    stock_id: str
+    shares_owned: str
+    average_buy_price: str
+    shares_shorted: str
+    average_short_price: str
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> Position:
+        return cls(str(value.get("stockId", "")), str(value.get("sharesOwned", "0")),
+                   str(value.get("averageBuyPrice", "0")), str(value.get("sharesShorted", "0")),
+                   str(value.get("averageShortPrice", "0")), value)
+
+
+@dataclass(frozen=True)
+class Cooldown:
+    duration_seconds: int
+    available_at_unix_seconds: int
+    remaining_seconds: int
+    active: bool
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> Cooldown:
+        return cls(int(value.get("durationSeconds", 0)),
+                   int(value.get("availableAtUnixSeconds", 0)),
+                   int(value.get("remainingSeconds", 0)), bool(value.get("active", False)), value)
+
+
+@dataclass(frozen=True)
+class TradeCooldowns:
+    server_now_unix_seconds: int
+    server_clock_synchronized: bool
+    buy: Cooldown
+    short_trade: Cooldown
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> TradeCooldowns:
+        return cls(int(value.get("serverNowUnixSeconds", 0)),
+                   bool(value.get("serverClockSynchronized", False)),
+                   Cooldown.from_dict(value.get("buy", {})),
+                   Cooldown.from_dict(value.get("shortTrade", {})), value)
+
+
+@dataclass(frozen=True)
+class AutoAction:
+    slot_index: int
+    stock_id: str
+    action_type: str
+    condition: str
+    target_price: float
+    amount_percentage: int
+    enabled: bool
+    cooldown_until_unix_seconds: int
+    cooldown_duration_seconds: int
+    cooldown_remaining_seconds: int
+    on_cooldown: bool
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> AutoAction:
+        return cls(int(value.get("slotIndex", -1)), str(value.get("stockId", "")),
+                   str(value.get("actionType", "")), str(value.get("condition", "")),
+                   float(value.get("targetPrice", 0)), int(value.get("amountPercentage", 0)),
+                   bool(value.get("enabled", False)), int(value.get("cooldownUntilUnixSeconds", 0)),
+                   int(value.get("cooldownDurationSeconds", 0)),
+                   int(value.get("cooldownRemainingSeconds", 0)),
+                   bool(value.get("onCooldown", False)), value)
+
+
+@dataclass(frozen=True)
+class AutoActions:
+    ready: bool
+    unlocked: bool
+    active: bool
+    slot_limit: int
+    configured_count: int
+    can_add_action: bool
+    cooldown_duration_seconds: int
+    actions: list[AutoAction]
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> AutoActions:
+        return cls(bool(value.get("ready", False)), bool(value.get("unlocked", False)),
+                   bool(value.get("active", False)), int(value.get("slotLimit", 0)),
+                   int(value.get("configuredCount", 0)), bool(value.get("canAddAction", False)),
+                   int(value.get("cooldownDurationSeconds", 0)),
+                   [AutoAction.from_dict(item) for item in value.get("actions", [])], value)
+
+
+@dataclass(frozen=True)
+class Snapshot:
+    ready: bool
+    server_tick: int
+    cash: str
+    level: int
+    stocks: list[Stock]
+    positions: list[Position]
+    cooldowns: TradeCooldowns
+    auto_actions: AutoActions
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> Snapshot:
+        return cls(bool(value.get("ready", False)), int(value.get("serverTick", 0)),
+                   str(value.get("cash", "0")), int(value.get("level", 0)),
+                   [Stock.from_dict(item) for item in value.get("stocks", [])],
+                   [Position.from_dict(item) for item in value.get("positions", [])],
+                   TradeCooldowns.from_dict(value.get("cooldowns", {})),
+                   AutoActions.from_dict(value.get("autoActions", {})), value)
+
+
+@dataclass(frozen=True)
+class TradeReceipt:
+    status: str
+    raw: dict[str, Any] = field(repr=False)
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> TradeReceipt:
+        return cls(str(value.get("status", "")), value)

screenstocks_bridge-0.2.0/src/screenstocks_bridge/protocol.py

@@ -0,0 +1,16 @@
+"""Protocol constants and errors shared by the Python bridge client."""
+
+MAX_FRAME_BYTES = 16 * 1024
+
+
+class BridgeError(RuntimeError):
+    """A transport, protocol, or game-side API error."""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+class _ReaderStopped(Exception):
+    pass

screenstocks_bridge-0.2.0/src/screenstocks_bridge.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: screenstocks-bridge
+Version: 0.2.0
+Summary: Python client for the local Screen Stocks BepInEx bridge
+License-Expression: MIT-0
+Project-URL: Homepage, https://github.com/fuubox/screen-stocks-bridge
+Project-URL: Documentation, https://github.com/fuubox/screen-stocks-bridge#readme
+Project-URL: Repository, https://github.com/fuubox/screen-stocks-bridge
+Project-URL: Issues, https://github.com/fuubox/screen-stocks-bridge/issues
+Keywords: screen-stocks,bepinex,game-modding,bridge
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Screen Stocks Python Bridge
+
+The `screenstocks-bridge` package is a Python client for the local API exposed
+by the Screen Stocks Bridge BepInEx plugin. It requires the plugin to be
+installed in the game and the game to be running. The package itself does not
+install or contact the game backend; it connects to the plugin on loopback.
+
+## Install
+
+```powershell
+python -m pip install screenstocks-bridge
+```
+
+Install the matching BepInEx plugin from the
+[GitHub releases](https://github.com/fuubox/screen-stocks-bridge/releases),
+then launch Screen Stocks. The default bridge address is `127.0.0.1:48721`.
+Read the token from `BepInEx/config/screenstocks.bridge.cfg` or the BepInEx
+log.
+
+## Connect
+
+```python
+from screenstocks_bridge import BridgeClient
+
+with BridgeClient(token="YOUR_TOKEN") as bridge:
+    state = bridge.snapshot()
+    print(state["ready"], state["cash"])
+    print(bridge.upgrades())
+```
+
+The client supports state and activity reads, trades, upgrade purchases, and
+auto-action controls. See the
+[bridge usage guide](https://github.com/fuubox/screen-stocks-bridge/blob/main/docs/bridge-usage.md)
+for the full API and its online behavior.

screenstocks_bridge-0.2.0/src/screenstocks_bridge.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/screenstocks_bridge/__init__.py
+src/screenstocks_bridge/client.py
+src/screenstocks_bridge/models.py
+src/screenstocks_bridge/protocol.py
+src/screenstocks_bridge.egg-info/PKG-INFO
+src/screenstocks_bridge.egg-info/SOURCES.txt
+src/screenstocks_bridge.egg-info/dependency_links.txt
+src/screenstocks_bridge.egg-info/top_level.txt

screenstocks_bridge-0.2.0/src/screenstocks_bridge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

screenstocks_bridge-0.2.0/src/screenstocks_bridge.egg-info/top_level.txt

@@ -0,0 +1 @@
+screenstocks_bridge