synpath 0.3.0__cp310-abi3-win_amd64.whl

synpath/__init__.py

@@ -0,0 +1,188 @@
+"""synpath — one API for prediction markets.
+
+```python
+import synpath
+
+kalshi = synpath.Kalshi()
+markets = kalshi.fetch_markets(limit=5)
+
+market = markets[0]
+yes = market.yes
+print(market.title, yes.quote.bid, yes.quote.ask, yes.quote.last)
+
+book = kalshi.fetch_order_book(yes.id)
+print(book.best_bid, book.best_ask)
+```
+
+Every venue exposes the same methods and returns the same types. What it will
+not do is make two venues look more alike than they are: the unit a volume is
+counted in, where a candle's prices came from, and whether a price is missing
+or merely zero are all carried in the response instead of being smoothed away.
+
+Check `exchange.has` before calling — a capability a venue lacks raises
+`NotSupported` rather than returning an empty list.
+"""
+from __future__ import annotations
+
+from . import ids
+from .base import Capability, Exchange, HttpClient, RateLimiter
+from .errors import (
+    AuthenticationError,
+    BadRequest,
+    BadSymbol,
+    ExchangeError,
+    ExchangeNotAvailable,
+    MarketNotFound,
+    NetworkError,
+    NotSupported,
+    RateLimitExceeded,
+    RequestTimeout,
+    SynpathError,
+)
+from .kalshi import Kalshi
+from .polymarket import Polymarket
+from .polymarket_us import PolymarketUS
+from .opinion import Opinion
+from .matching import match_event, match_market
+from .history import fetch_order_book_at, fetch_order_book_range, fetch_trades_range
+from .bucket import Bucket, BucketMember, BucketOrderReport, BucketPosition
+from .types import (
+    BookModel,
+    Candle,
+    Event,
+    EventMatch,
+    FeeSchedule,
+    Outcome,
+    Market,
+    MarketLink,
+    MarketMatch,
+    MarketStats,
+    MarketStatus,
+    OrderBook,
+    OrderLevel,
+    Page,
+    PriceSource,
+    Quote,
+    Series,
+    Trade,
+    HistoryMetadata,
+    HistoryCoverage,
+    HistoricalTrade,
+    HistoricalOrderBook,
+    HistoricalBookChange,
+    HistoricalBookSegment,
+    OrderBookAtResponse,
+    OrderBookRangeResponse,
+    TradesRangeResponse,
+)
+
+__version__ = "0.3.0"
+
+exchanges: dict[str, type[Exchange]] = {
+    "kalshi": Kalshi,
+    "polymarket": Polymarket,
+    "polymarket_us": PolymarketUS,
+    "opinion": Opinion,
+}
+"""Every venue this library speaks, by id."""
+
+
+def exchange(venue: str, **kwargs) -> Exchange:
+    """Construct a venue adapter by id: `synpath.exchange("kalshi")`."""
+    try:
+        return exchanges[venue](**kwargs)
+    except KeyError:
+        raise BadRequest(
+            f"unknown venue {venue!r}; available: {', '.join(sorted(exchanges))}"
+        ) from None
+
+
+# Order entry lives in `synpath.trading`, but it is part of the same install
+# and the same API, so its public names are available here too:
+# `from synpath import KalshiTrading, OrderRequest`. The subpackage import
+# keeps working. Imported last, after the read API it builds on.
+from .trading import (
+    TradingExchange, KalshiTrading, PolymarketTrading, PolymarketUSTrading, PolymarketUSExchangeTrading,
+    OpinionTrading,
+    Account, Balance, EditRequest, FeeEstimate, Fill, HeldBy, Liquidity,
+    Order, OrderRequest, OrderStatus, OrderType, Position, PositionSide,
+    Precision, Settlement, SettlementState, Side, TimeInForce,
+    CredentialsMissing, DuplicateClientOrderId, InsufficientFunds, InvalidOrder,
+    MarketHalted, OrderNotFound, OrderRejected, PermissionDenied,
+    RateBudgetExceeded, RiskRejected,
+)
+from .trading.credentials import load_credentials, require
+from .client import Client
+
+# Live streams live in `synpath.ws` and are exported here too. The event types
+# come in eagerly; the stream classes are resolved on first use through
+# `__getattr__` below, the same way `synpath.ws` itself defers them. The
+# streams' base event class is `synpath.ws.Event`; here it is `StreamEvent`,
+# because `synpath.Event` is already a venue event (a group of markets).
+from .ws import (
+    Stream, StreamStats, BookEvent, BookLevel, QuoteEvent, TradeEvent, OrderEvent, FillEvent, PositionEvent,
+    BalanceEvent, MarketStatusEvent, VenueEvent, StreamStatusEvent, LocalBook,
+)
+from .ws import Event as StreamEvent
+
+_STREAM_CLASSES = (
+    "KalshiStream", "PolymarketMarketStream", "PolymarketUserStream", "PolymarketUSMarketStream",
+    "PolymarketUSPrivateStream", "PolymarketUSExchangeOrderStream", "PolymarketUSExchangeDropCopyStream",
+    "PolymarketUSExchangeTradeCaptureStream", "PolymarketUSExchangePositionChangeStream",
+    "PolymarketUSExchangeInstrumentStream", "PolymarketUSExchangePositionStream",
+    "PolymarketUSExchangeMarketDataStream", "PolymarketUSExchangeBalanceLedgerStream",
+    "OpinionMarketStream", "OpinionUserStream",
+)
+_SERVER_NAMES = ("create_app", "create_trading_app", "VenueRegistry", "ControlStore", "Principal")
+
+
+def __getattr__(name: str):
+    """Stream classes and the HTTP server, resolved on first use.
+
+    Both are part of the package, but neither is imported by `import synpath`:
+    a stream module pulls in a venue's WebSocket client, and the server pulls
+    in FastAPI, and a notebook reading quotes needs neither.
+    """
+    if name in _STREAM_CLASSES:
+        from . import ws
+        return getattr(ws, name)
+    if name in _SERVER_NAMES:
+        from . import server
+        return getattr(server, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "Kalshi", "Polymarket", "PolymarketUS", "Opinion", "Exchange", "exchange", "exchanges",
+    "Capability", "HttpClient", "RateLimiter",
+    "Market", "Event", "Outcome", "Quote", "MarketStats", "OrderBook",
+    "OrderLevel", "Trade", "Candle", "FeeSchedule", "Series", "Page",
+    "HistoryMetadata", "HistoryCoverage", "HistoricalTrade", "HistoricalOrderBook",
+    "HistoricalBookChange", "HistoricalBookSegment", "OrderBookAtResponse",
+    "OrderBookRangeResponse", "TradesRangeResponse",
+    "match_market", "match_event", "ids",
+    "fetch_order_book_at", "fetch_order_book_range", "fetch_trades_range",
+    "MarketMatch", "EventMatch", "MarketLink",
+    "Bucket", "BucketMember", "BucketOrderReport", "BucketPosition",
+    "MarketStatus", "BookModel", "PriceSource",
+    "SynpathError", "NetworkError", "ExchangeError", "ExchangeNotAvailable",
+    "RequestTimeout", "RateLimitExceeded", "BadRequest", "BadSymbol",
+    "MarketNotFound", "NotSupported", "AuthenticationError",
+    # order entry
+    "TradingExchange", "KalshiTrading", "PolymarketTrading", "PolymarketUSTrading", "PolymarketUSExchangeTrading",
+    "OpinionTrading",
+    "Account", "Balance", "EditRequest", "FeeEstimate", "Fill", "HeldBy", "Liquidity",
+    "Order", "OrderRequest", "OrderStatus", "OrderType", "Position", "PositionSide",
+    "Precision", "Settlement", "SettlementState", "Side", "TimeInForce",
+    "CredentialsMissing", "DuplicateClientOrderId", "InsufficientFunds", "InvalidOrder",
+    "MarketHalted", "OrderNotFound", "OrderRejected", "PermissionDenied",
+    "RateBudgetExceeded", "RiskRejected",
+    "load_credentials", "require", "Client",
+    # live streams
+    "Stream", "StreamStats", "StreamEvent", "BookEvent", "BookLevel", "QuoteEvent", "TradeEvent", "OrderEvent",
+    "FillEvent", "PositionEvent", "BalanceEvent", "MarketStatusEvent", "VenueEvent", "StreamStatusEvent",
+    "LocalBook", *_STREAM_CLASSES,
+    # HTTP server
+    *_SERVER_NAMES,
+    "__version__",
+]

synpath/__main__.py

@@ -0,0 +1,66 @@
+"""`synpath`: one command for everything the package runs.
+
+```bash
+synpath init                   # asks for your venue keys and writes .env (readable by you only)
+synpath serve                  # engine + streams + HTTP API, in one process
+synpath doctor                 # which venue credentials load (prints no secret)
+synpath status | halt | resume | eod     # ask or tell a running engine, through its journal
+synpath run --config engine.toml         # the engine alone, no HTTP
+synpath schema [--trading] --out openapi.json
+synpath bootstrap              # the first key for a control database
+synpath login                  # Google sign-in in your browser; return to CLI
+synpath keys create|list|revoke # manage hosted history API keys
+synpath logout                 # end the key-management session
+```
+
+`synpath engine ...`, `synpath server ...` and `synpath trading ...` reach
+the underlying `python -m synpath.<module>` commands with every option.
+"""
+from __future__ import annotations
+
+import importlib
+import sys
+
+MODULES = {
+    "serve": "synpath.server.serve",
+    "engine": "synpath.engine.__main__",
+    "server": "synpath.server.__main__",
+    "trading": "synpath.trading.__main__",
+    "init": "synpath.trading.init",
+    "login": "synpath.hosted_auth",
+    "keys": "synpath.hosted_auth",
+    "logout": "synpath.hosted_auth",
+}
+SHORTCUTS = {
+    "run": ("engine", ["run"]),
+    "status": ("engine", ["status"]),
+    "halt": ("engine", ["halt"]),
+    "resume": ("engine", ["resume"]),
+    "eod": ("engine", ["eod"]),
+    "schema": ("server", ["schema"]),
+    "bootstrap": ("server", ["bootstrap"]),
+    "doctor": ("trading", ["doctor"]),
+}
+
+USAGE = __doc__.split("```bash", 1)[1].split("```", 1)[0].strip()
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        print("usage: synpath <command> [options]\n\n" + USAGE)
+        return 0
+    command, rest = argv[0], argv[1:]
+    if command in SHORTCUTS:
+        command, prefix = SHORTCUTS[command]
+        rest = prefix + rest
+    if command not in MODULES:
+        print(f"synpath: unknown command {command!r}\n\nusage: synpath <command> [options]\n\n" + USAGE, file=sys.stderr)
+        return 2
+    module = importlib.import_module(MODULES[command])
+    result = getattr(module, command if command in ("login", "keys", "logout") else "main")(rest)
+    return int(result or 0)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

synpath/_native.py

@@ -0,0 +1,32 @@
+"""Which implementation of the hot paths is in use: the Rust core or Python.
+
+The Rust core ships inside the wheel as `synpath._core`. Every class it
+provides has a pure-Python twin with the same interface, so the library works
+the same either way and the choice is invisible to callers:
+
+* the Rust one, when the extension is installed (every published wheel);
+* the Python one, when it is not (a source checkout without Rust), or when
+  `SYNPATH_PURE_PYTHON=1` is set -- which the test suite uses to run every
+  test against both.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any
+
+FORCED_PURE = os.environ.get("SYNPATH_PURE_PYTHON", "").strip().lower() in ("1", "true", "yes")
+
+core: Any = None
+if not FORCED_PURE:
+    try:
+        from . import _core as core  # type: ignore[no-redef]
+    except ImportError:  # pragma: no cover - only without a built extension
+        core = None
+
+ENABLED = core is not None
+"""True when the Rust core is in use."""
+
+
+def pick(name: str, fallback: Any) -> Any:
+    """`synpath._core.<name>` when the Rust core is in use, else `fallback`."""
+    return getattr(core, name) if core is not None else fallback