polynode 0.10.4__tar.gz → 0.10.6__tar.gz

{polynode-0.10.4 → polynode-0.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.10.4
+Version: 0.10.6
 Summary: Python SDK for the PolyNode real-time prediction market data platform
 Project-URL: Homepage, https://polynode.dev
 Project-URL: Documentation, https://docs.polynode.dev
@@ -59,6 +59,32 @@ with PolyNode(api_key="pn_live_...") as pn:
     settlements = pn.recent_settlements(count=5)
 ```
 
+### Sports and Online Context
+
+```python
+from polynode import PolyNode
+
+with PolyNode(api_key="pn_live_...") as pn:
+    state = pn.sports_game_state(
+        "nba-cle-nyk-2026-05-31",
+        price_limit_tokens=20,
+    )
+
+    context = pn.sports_game_context(
+        "nba-cle-nyk-2026-05-31",
+        sources=["online"],
+        query_set="injuries",
+        max_queries=2,
+        max_per_query=5,
+        include_state=True,
+    )
+
+    web = pn.search_online(
+        "Cavaliers Knicks injury news",
+        max_results=5,
+    )
+```
+
 ### Async REST
 
 ```python

{polynode-0.10.4 → polynode-0.10.6}/README.md

@@ -26,6 +26,32 @@ with PolyNode(api_key="pn_live_...") as pn:
     settlements = pn.recent_settlements(count=5)
 ```
 
+### Sports and Online Context
+
+```python
+from polynode import PolyNode
+
+with PolyNode(api_key="pn_live_...") as pn:
+    state = pn.sports_game_state(
+        "nba-cle-nyk-2026-05-31",
+        price_limit_tokens=20,
+    )
+
+    context = pn.sports_game_context(
+        "nba-cle-nyk-2026-05-31",
+        sources=["online"],
+        query_set="injuries",
+        max_queries=2,
+        max_per_query=5,
+        include_state=True,
+    )
+
+    web = pn.search_online(
+        "Cavaliers Knicks injury news",
+        max_results=5,
+    )
+```
+
 ### Async REST
 
 ```python

polynode-0.10.6/polynode/_version.py

@@ -0,0 +1 @@
+__version__ = "0.10.6"

{polynode-0.10.4 → polynode-0.10.6}/polynode/client.py

@@ -32,6 +32,14 @@ from .types.rest import (
 from .types.enums import CandleResolution, MarketSortField
 
 
+def _csv_param(value: Any) -> Any:
+    if value is None or isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple, set)):
+        return ",".join(str(item) for item in value)
+    return value
+
+
 class PolyNode:
     """Synchronous PolyNode REST client."""
 
@@ -187,6 +195,152 @@ class PolyNode:
             self._fetch("/v1/search", query={"q": query, "limit": limit, "include_inactive": include_inactive})
         )
 
+    def search_online(
+        self,
+        query: str,
+        *,
+        max_results: int | None = None,
+        engines: str | list[str] | tuple[str, ...] | set[str] | None = None,
+        language: str | None = None,
+        time_range: str | None = None,
+        safe_search: int | None = None,
+        cache_ttl_seconds: int | None = None,
+    ) -> dict:
+        return self._fetch(
+            "/v2/search/online",
+            query={
+                "q": query,
+                "max_results": max_results,
+                "engines": _csv_param(engines),
+                "language": language,
+                "time_range": time_range,
+                "safe_search": safe_search,
+                "cache_ttl_seconds": cache_ttl_seconds,
+            },
+        )
+
+    # ── Sports ──
+
+    def sports_leagues(self) -> dict:
+        return self._fetch("/v2/sports/leagues")
+
+    def sports_teams(self, league: str, *, limit: int | None = None, offset: int | None = None) -> dict:
+        return self._fetch(
+            f"/v2/sports/leagues/{quote(league, safe='')}/teams",
+            query={"limit": limit, "offset": offset},
+        )
+
+    def sports_games(
+        self,
+        league: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        sort: str | None = None,
+        direction: str | None = None,
+    ) -> dict:
+        return self._fetch(
+            f"/v2/sports/leagues/{quote(league, safe='')}/games",
+            query={"status": status, "limit": limit, "offset": offset, "sort": sort, "direction": direction},
+        )
+
+    def sports_game(self, slug: str) -> dict:
+        return self._fetch(f"/v2/sports/games/{quote(slug, safe='')}")
+
+    def sports_game_state(
+        self,
+        slug: str,
+        *,
+        include_history: bool | None = None,
+        price_limit_tokens: int | None = None,
+        history_limit_tokens: int | None = None,
+        start_ts: int | str | None = None,
+        end_ts: int | str | None = None,
+        interval: str | None = None,
+        fidelity: int | None = None,
+    ) -> dict:
+        return self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/state",
+            query={
+                "include_history": include_history,
+                "price_limit_tokens": price_limit_tokens,
+                "history_limit_tokens": history_limit_tokens,
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "interval": interval,
+                "fidelity": fidelity,
+            },
+        )
+
+    def sports_game_context(
+        self,
+        slug: str,
+        *,
+        sources: str | list[str] | tuple[str, ...] | set[str] | None = None,
+        query_set: str | None = None,
+        max_queries: int | None = None,
+        max_per_query: int | None = None,
+        include_state: bool | None = None,
+        price_limit_tokens: int | None = None,
+    ) -> dict:
+        return self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/context",
+            query={
+                "sources": _csv_param(sources),
+                "query_set": query_set,
+                "max_queries": max_queries,
+                "max_per_query": max_per_query,
+                "include_state": include_state,
+                "price_limit_tokens": price_limit_tokens,
+            },
+        )
+
+    def sports_game_prices(self, slug: str, *, limit_tokens: int | None = None) -> dict:
+        return self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/prices",
+            query={"limit_tokens": limit_tokens},
+        )
+
+    def sports_game_history(
+        self,
+        slug: str,
+        *,
+        start_ts: int | str | None = None,
+        end_ts: int | str | None = None,
+        interval: str | None = None,
+        fidelity: int | None = None,
+        limit_tokens: int | None = None,
+    ) -> dict:
+        return self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/history",
+            query={
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "interval": interval,
+                "fidelity": fidelity,
+                "limit_tokens": limit_tokens,
+            },
+        )
+
+    def sports_market_types(self) -> dict:
+        return self._fetch("/v2/sports/market-types")
+
+    def sports_series(self, *, status: str | None = None, limit: int | None = None) -> dict:
+        return self._fetch("/v2/sports/series", query={"status": status, "limit": limit})
+
+    def sports_tournaments(self) -> dict:
+        return self._fetch("/v2/sports/tournaments")
+
+    def sports_live(self) -> dict:
+        return self._fetch("/v2/sports/live")
+
+    def sports_summary(self) -> dict:
+        return self._fetch("/v2/sports/summary")
+
+    def sports_search(self, query: str, *, limit: int | None = None) -> dict:
+        return self._fetch("/v2/sports/search", query={"q": query, "limit": limit})
+
     # ── Pricing ──
 
     def candles(
@@ -490,6 +644,152 @@ class AsyncPolyNode:
             await self._fetch("/v1/search", query={"q": query, "limit": limit, "include_inactive": include_inactive})
         )
 
+    async def search_online(
+        self,
+        query: str,
+        *,
+        max_results: int | None = None,
+        engines: str | list[str] | tuple[str, ...] | set[str] | None = None,
+        language: str | None = None,
+        time_range: str | None = None,
+        safe_search: int | None = None,
+        cache_ttl_seconds: int | None = None,
+    ) -> dict:
+        return await self._fetch(
+            "/v2/search/online",
+            query={
+                "q": query,
+                "max_results": max_results,
+                "engines": _csv_param(engines),
+                "language": language,
+                "time_range": time_range,
+                "safe_search": safe_search,
+                "cache_ttl_seconds": cache_ttl_seconds,
+            },
+        )
+
+    # ── Sports ──
+
+    async def sports_leagues(self) -> dict:
+        return await self._fetch("/v2/sports/leagues")
+
+    async def sports_teams(self, league: str, *, limit: int | None = None, offset: int | None = None) -> dict:
+        return await self._fetch(
+            f"/v2/sports/leagues/{quote(league, safe='')}/teams",
+            query={"limit": limit, "offset": offset},
+        )
+
+    async def sports_games(
+        self,
+        league: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        sort: str | None = None,
+        direction: str | None = None,
+    ) -> dict:
+        return await self._fetch(
+            f"/v2/sports/leagues/{quote(league, safe='')}/games",
+            query={"status": status, "limit": limit, "offset": offset, "sort": sort, "direction": direction},
+        )
+
+    async def sports_game(self, slug: str) -> dict:
+        return await self._fetch(f"/v2/sports/games/{quote(slug, safe='')}")
+
+    async def sports_game_state(
+        self,
+        slug: str,
+        *,
+        include_history: bool | None = None,
+        price_limit_tokens: int | None = None,
+        history_limit_tokens: int | None = None,
+        start_ts: int | str | None = None,
+        end_ts: int | str | None = None,
+        interval: str | None = None,
+        fidelity: int | None = None,
+    ) -> dict:
+        return await self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/state",
+            query={
+                "include_history": include_history,
+                "price_limit_tokens": price_limit_tokens,
+                "history_limit_tokens": history_limit_tokens,
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "interval": interval,
+                "fidelity": fidelity,
+            },
+        )
+
+    async def sports_game_context(
+        self,
+        slug: str,
+        *,
+        sources: str | list[str] | tuple[str, ...] | set[str] | None = None,
+        query_set: str | None = None,
+        max_queries: int | None = None,
+        max_per_query: int | None = None,
+        include_state: bool | None = None,
+        price_limit_tokens: int | None = None,
+    ) -> dict:
+        return await self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/context",
+            query={
+                "sources": _csv_param(sources),
+                "query_set": query_set,
+                "max_queries": max_queries,
+                "max_per_query": max_per_query,
+                "include_state": include_state,
+                "price_limit_tokens": price_limit_tokens,
+            },
+        )
+
+    async def sports_game_prices(self, slug: str, *, limit_tokens: int | None = None) -> dict:
+        return await self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/prices",
+            query={"limit_tokens": limit_tokens},
+        )
+
+    async def sports_game_history(
+        self,
+        slug: str,
+        *,
+        start_ts: int | str | None = None,
+        end_ts: int | str | None = None,
+        interval: str | None = None,
+        fidelity: int | None = None,
+        limit_tokens: int | None = None,
+    ) -> dict:
+        return await self._fetch(
+            f"/v2/sports/games/{quote(slug, safe='')}/history",
+            query={
+                "start_ts": start_ts,
+                "end_ts": end_ts,
+                "interval": interval,
+                "fidelity": fidelity,
+                "limit_tokens": limit_tokens,
+            },
+        )
+
+    async def sports_market_types(self) -> dict:
+        return await self._fetch("/v2/sports/market-types")
+
+    async def sports_series(self, *, status: str | None = None, limit: int | None = None) -> dict:
+        return await self._fetch("/v2/sports/series", query={"status": status, "limit": limit})
+
+    async def sports_tournaments(self) -> dict:
+        return await self._fetch("/v2/sports/tournaments")
+
+    async def sports_live(self) -> dict:
+        return await self._fetch("/v2/sports/live")
+
+    async def sports_summary(self) -> dict:
+        return await self._fetch("/v2/sports/summary")
+
+    async def sports_search(self, query: str, *, limit: int | None = None) -> dict:
+        return await self._fetch("/v2/sports/search", query={"q": query, "limit": limit})
+
     # ── Pricing ──
 
     async def candles(

{polynode-0.10.4 → polynode-0.10.6}/polynode/engine.py

@@ -120,6 +120,7 @@ class OrderbookEngine:
         self._route_update(update)
 
     def _on_price(self, change: PriceChange) -> None:
+        self._state.apply_price_change(change)
         for h in self._handlers["price"]:
             h(change)
         for view in self._views:

{polynode-0.10.4 → polynode-0.10.6}/polynode/orderbook.py

@@ -28,7 +28,7 @@ class OrderbookWS:
 
     def __init__(self, api_key: str, ob_url: str, *, compress: bool = True, auto_reconnect: bool = True,
                  max_reconnect_attempts: int = 0, reconnect_base_delay: float = 1.0,
-                 reconnect_max_delay: float = 30.0) -> None:
+                 reconnect_max_delay: float = 30.0, subscribe_timeout: float = 30.0) -> None:
         self._api_key = api_key
         self._ob_url = ob_url
         self._compress = compress
@@ -36,12 +36,14 @@ class OrderbookWS:
         self._max_reconnect = max_reconnect_attempts
         self._base_delay = reconnect_base_delay
         self._max_delay = reconnect_max_delay
+        self._subscribe_timeout = subscribe_timeout
 
         self._socket: Any = None
         self._connected = False
         self._intentional_close = False
         self._reconnect_attempts = 0
         self._token_ids: list[str] = []
+        self._pending_subscribe: asyncio.Future | None = None
         self._recv_task: asyncio.Task | None = None
 
         self._handlers: dict[str, list[Callable]] = {
@@ -92,14 +94,20 @@ class OrderbookWS:
         return self
 
     async def subscribe(self, token_ids: list[str]) -> None:
-        self._token_ids = token_ids
+        self._token_ids = list(token_ids)
         await self._ensure_connected()
-        await self._send(json.dumps({"action": "subscribe", "markets": token_ids}))
-
-    def unsubscribe(self) -> None:
-        self._token_ids = []
+        await self._send_subscribe(self._token_ids)
+
+    def unsubscribe(self, token_ids: list[str] | None = None) -> None:
+        if token_ids is None:
+            self._token_ids = []
+            msg = {"action": "unsubscribe"}
+        else:
+            remove = set(token_ids)
+            self._token_ids = [token_id for token_id in self._token_ids if token_id not in remove]
+            msg = {"action": "unsubscribe", "markets": token_ids}
         if self._connected and self._socket:
-            asyncio.ensure_future(self._send(json.dumps({"action": "unsubscribe"})))
+            asyncio.ensure_future(self._send(json.dumps(msg)))
 
     async def connect(self) -> None:
         if self._connected and self._socket:
@@ -157,6 +165,9 @@ class OrderbookWS:
             return
         finally:
             self._connected = False
+            self._reject_pending_subscribe(
+                WsError("WebSocket connection closed before orderbook subscription was acknowledged")
+            )
             reason = "closed" if self._intentional_close else "lost"
             for h in self._on_disconnect:
                 h(reason)
@@ -167,11 +178,44 @@ class OrderbookWS:
         if self._socket and self._connected:
             await self._socket.send(data)
 
+    async def _send_subscribe(self, token_ids: list[str]) -> None:
+        if self._pending_subscribe and not self._pending_subscribe.done():
+            raise WsError("Subscribe already pending")
+
+        fut: asyncio.Future[None] = asyncio.get_running_loop().create_future()
+        self._pending_subscribe = fut
+        await self._send(json.dumps({"action": "subscribe", "markets": token_ids}))
+
+        try:
+            await asyncio.wait_for(fut, timeout=self._subscribe_timeout)
+        except asyncio.TimeoutError:
+            if self._pending_subscribe is fut:
+                self._pending_subscribe = None
+            raise WsError(f"Subscribe timed out after {self._subscribe_timeout:g} seconds")
+
+    def _resolve_pending_subscribe(self) -> None:
+        fut = self._pending_subscribe
+        self._pending_subscribe = None
+        if fut and not fut.done():
+            fut.set_result(None)
+
+    def _reject_pending_subscribe(self, err: WsError) -> None:
+        fut = self._pending_subscribe
+        self._pending_subscribe = None
+        if fut and not fut.done():
+            fut.set_exception(err)
+
     def _handle_message(self, text: str) -> None:
         msg = json.loads(text)
 
-        if msg.get("error"):
-            err_msg = ObErrorMessage.model_validate(msg)
+        if msg.get("error") or msg.get("type") == "error":
+            err_msg = ObErrorMessage(
+                error=str(msg.get("error") or msg.get("code") or "error"),
+                message=str(msg.get("message") or msg.get("error") or "Unknown orderbook error"),
+                max=msg.get("max"),
+                requested=msg.get("requested"),
+            )
+            self._reject_pending_subscribe(WsError(err_msg.message, err_msg.error))
             for h in self._handlers["error"]:
                 h(err_msg)
             return
@@ -180,6 +224,7 @@ class OrderbookWS:
 
         if msg_type == "subscribed":
             sub_msg = SubscribedMessage(markets=msg.get("markets", 0))
+            self._resolve_pending_subscribe()
             for h in self._handlers["subscribed"]:
                 h(sub_msg)
 
@@ -238,6 +283,6 @@ class OrderbookWS:
             for h in self._on_reconnect:
                 h(self._reconnect_attempts)
             if self._token_ids:
-                await self._send(json.dumps({"action": "subscribe", "markets": self._token_ids}))
+                await self._send_subscribe(self._token_ids)
         except Exception:
             pass

{polynode-0.10.4 → polynode-0.10.6}/polynode/orderbook_state.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from .types.orderbook import BookSnapshot, BookUpdate, OrderbookLevel, PriceChange
+from .types.orderbook import BookSnapshot, BookUpdate, OrderbookLevel, PriceChange, PriceChangeAsset
 
 
 class LocalOrderbook:
@@ -10,6 +10,7 @@ class LocalOrderbook:
 
     def __init__(self) -> None:
         self._books: dict[str, tuple[list[OrderbookLevel], list[OrderbookLevel]]] = {}
+        self._last_prices: dict[str, PriceChangeAsset] = {}
 
     def apply_snapshot(self, snap: BookSnapshot) -> None:
         bids = sorted(list(snap.bids), key=lambda l: float(l.price), reverse=True)
@@ -25,11 +26,15 @@ class LocalOrderbook:
         self._books[update.asset_id] = (new_bids, new_asks)
 
     def apply_price_change(self, change: PriceChange) -> None:
-        pass
+        for asset in change.assets:
+            self._last_prices[asset.asset_id] = asset
 
     def get_book(self, asset_id: str) -> tuple[list[OrderbookLevel], list[OrderbookLevel]] | None:
         return self._books.get(asset_id)
 
+    def get_last_price(self, asset_id: str) -> PriceChangeAsset | None:
+        return self._last_prices.get(asset_id)
+
     def get_best_bid(self, asset_id: str) -> OrderbookLevel | None:
         book = self._books.get(asset_id)
         if book and book[0]:
@@ -55,6 +60,7 @@ class LocalOrderbook:
 
     def clear(self) -> None:
         self._books.clear()
+        self._last_prices.clear()
 
 
 def _apply_deltas(

{polynode-0.10.4 → polynode-0.10.6}/polynode/subscription.py

@@ -12,6 +12,8 @@ from .types.ws import SubscriptionFilters
 if TYPE_CHECKING:
     from .ws import PolyNodeWS
 
+PRE_ACK_REPLAY_LIMIT = 1000
+
 
 class SubscriptionBuilder:
     """Fluent builder for WebSocket subscriptions."""
@@ -79,6 +81,7 @@ class Subscription:
         self._id: str | None = None
         self._handlers: dict[str, set[Callable]] = {}
         self._queue: asyncio.Queue[PolyNodeEvent | None] = asyncio.Queue()
+        self._pre_ack_replay: list[PolyNodeEvent] = []
         self._closed = False
 
     @property
@@ -92,6 +95,10 @@ class Subscription:
         if type not in self._handlers:
             self._handlers[type] = set()
         self._handlers[type].add(handler)
+        for event in self._pre_ack_replay:
+            event_type = event.event_type  # type: ignore[union-attr]
+            if type == "*" or type == event_type:
+                handler(event)
         return self
 
     def off(self, type: str, handler: Callable) -> Subscription:
@@ -114,6 +121,12 @@ class Subscription:
         # Async iterator queue
         self._queue.put_nowait(event)
 
+    def _emit_pre_ack(self, event: PolyNodeEvent) -> None:
+        self._pre_ack_replay.append(event)
+        if len(self._pre_ack_replay) > PRE_ACK_REPLAY_LIMIT:
+            self._pre_ack_replay = self._pre_ack_replay[-PRE_ACK_REPLAY_LIMIT:]
+        self._emit(event)
+
     def unsubscribe(self) -> None:
         self._closed = True
         self._queue.put_nowait(None)

{polynode-0.10.4 → polynode-0.10.6}/polynode/types/ws.py

@@ -36,3 +36,4 @@ class WsOptions:
     max_reconnect_attempts: int = 0  # 0 = infinite
     reconnect_base_delay: float = 1.0
     reconnect_max_delay: float = 30.0
+    subscribe_timeout: float = 30.0

{polynode-0.10.4 → polynode-0.10.6}/polynode/ws.py

@@ -29,6 +29,32 @@ def _parse_event(data: dict) -> PolyNodeEvent | None:
         return None
 
 
+def _subscription_accepts_event(sub_type: SubscriptionType, event_type: str) -> bool:
+    if sub_type in ("global", "markets"):
+        return True
+    if sub_type == "settlements":
+        return event_type in {"settlement", "status_update"}
+    if sub_type in ("trades", "large_trades"):
+        return event_type == "trade"
+    if sub_type in ("prices", "chainlink"):
+        return event_type == "price_feed"
+    if sub_type == "blocks":
+        return event_type == "block"
+    if sub_type == "wallets":
+        return event_type in {
+            "settlement",
+            "trade",
+            "status_update",
+            "position_change",
+            "deposit",
+            "position_split",
+            "position_merge",
+        }
+    if sub_type == "oracle":
+        return event_type == "oracle"
+    return True
+
+
 class PolyNodeWS:
     """Async WebSocket client with auto-reconnect and subscription management."""
 
@@ -41,6 +67,7 @@ class PolyNodeWS:
         self._max_reconnect = opts.max_reconnect_attempts
         self._base_delay = opts.reconnect_base_delay
         self._max_delay = opts.reconnect_max_delay
+        self._subscribe_timeout = opts.subscribe_timeout
 
         self._socket: Any = None
         self._connected = False
@@ -105,11 +132,11 @@ class PolyNodeWS:
         await self._send(json.dumps(msg))
 
         try:
-            return await asyncio.wait_for(fut, timeout=10.0)
+            return await asyncio.wait_for(fut, timeout=self._subscribe_timeout)
         except asyncio.TimeoutError:
             # Remove from pending
             self._pending = [(s, f) for s, f in self._pending if f is not fut]
-            raise WsError("Subscribe timed out after 10 seconds")
+            raise WsError(f"Subscribe timed out after {self._subscribe_timeout:g} seconds")
 
     def _unsubscribe(self, subscription_id: str | None = None) -> None:
         if subscription_id:
@@ -182,6 +209,8 @@ class PolyNodeWS:
             return
         finally:
             self._connected = False
+            if self._pending:
+                self._reject_pending(WsError("WebSocket connection closed before subscription was acknowledged"))
             reason = "closed" if self._intentional_close else "lost"
             for h in self._on_disconnect:
                 h(reason)
@@ -250,6 +279,22 @@ class PolyNodeWS:
     def _route_event(self, event: PolyNodeEvent) -> None:
         for sub in self._subscriptions.values():
             sub._emit(event)
+        self._route_pending_event(event)
+
+    def _route_pending_event(self, event: PolyNodeEvent) -> None:
+        if not self._pending:
+            return
+        event_type = event.event_type  # type: ignore[union-attr]
+        for sub, _ in self._pending:
+            if _subscription_accepts_event(sub.type, event_type):
+                sub._emit_pre_ack(event)
+
+    def _reject_pending(self, err: WsError) -> None:
+        pending = self._pending
+        self._pending = []
+        for _, fut in pending:
+            if not fut.done():
+                fut.set_exception(err)
 
     async def _schedule_reconnect(self) -> None:
         if self._max_reconnect and self._reconnect_attempts >= self._max_reconnect:

{polynode-0.10.4 → polynode-0.10.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polynode"
-version = "0.10.4"
+version = "0.10.6"
 description = "Python SDK for the PolyNode real-time prediction market data platform"
 readme = "README.md"
 requires-python = ">=3.10"

{polynode-0.10.4 → polynode-0.10.6}/tests/conftest.py

@@ -1,8 +1,10 @@
 """Shared test fixtures."""
 
+import os
+
 import pytest
 
-TEST_KEY = "pn_live_test_session_tracking_51eca107e9b347b589f5b0a04f98eb1d"
+TEST_KEY = os.getenv("POLYNODE_API_KEY")
 BASE_URL = "https://api.polynode.dev"
 WS_URL = "wss://ws.polynode.dev/ws"
 OB_URL = "wss://ob.polynode.dev/ws"
@@ -10,20 +12,22 @@ OB_URL = "wss://ob.polynode.dev/ws"
 
 @pytest.fixture
 def api_key():
+    if not TEST_KEY:
+        pytest.skip("POLYNODE_API_KEY is not set")
     return TEST_KEY
 
 
 @pytest.fixture
-def client():
+def client(api_key):
     from polynode import PolyNode
-    pn = PolyNode(api_key=TEST_KEY)
+    pn = PolyNode(api_key=api_key)
     yield pn
     pn.close()
 
 
 @pytest.fixture
-async def async_client():
+async def async_client(api_key):
     from polynode import AsyncPolyNode
-    pn = AsyncPolyNode(api_key=TEST_KEY)
+    pn = AsyncPolyNode(api_key=api_key)
     yield pn
     await pn.close()

polynode-0.10.6/tests/test_client.py

@@ -0,0 +1,141 @@
+"""Tests for the sync REST client."""
+
+import os
+
+import pytest
+from polynode import PolyNode
+from polynode.types.rest import StatusResponse, MarketsResponse, SettlementsResponse
+
+TEST_KEY = os.getenv("POLYNODE_API_KEY")
+
+
+@pytest.fixture
+def pn():
+    if not TEST_KEY:
+        pytest.skip("POLYNODE_API_KEY is not set")
+    client = PolyNode(api_key=TEST_KEY)
+    yield client
+    client.close()
+
+
+def test_healthz(pn):
+    result = pn.healthz()
+    assert result == "ok" or "ok" in str(result).lower()
+
+
+def test_status(pn):
+    result = pn.status()
+    assert isinstance(result, StatusResponse)
+    assert result.uptime_seconds > 0
+    assert result.state.market_count > 0
+
+
+def test_markets(pn):
+    result = pn.markets(count=3)
+    assert isinstance(result, MarketsResponse)
+    assert result.count > 0
+    assert len(result.markets) <= 3
+
+
+def test_recent_settlements(pn):
+    result = pn.recent_settlements(count=1)
+    assert isinstance(result, SettlementsResponse)
+    assert result.count >= 0
+
+
+def test_search(pn):
+    result = pn.search("election", limit=3)
+    assert result.query == "election"
+    assert result.count >= 0
+
+
+def test_search_online_builds_expected_path():
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
+    calls = []
+
+    def fake_fetch(path, **kwargs):
+        calls.append((path, kwargs))
+        return {"ok": True}
+
+    client._fetch = fake_fetch  # type: ignore[method-assign]
+    try:
+        assert client.search_online(
+            "Cavaliers Knicks injury news",
+            max_results=5,
+            engines=["brave", "bing"],
+            language="en-US",
+            time_range="day",
+            safe_search=0,
+            cache_ttl_seconds=300,
+        )["ok"]
+    finally:
+        client.close()
+
+    assert calls[0][0] == "/v2/search/online"
+    assert calls[0][1]["query"] == {
+        "q": "Cavaliers Knicks injury news",
+        "max_results": 5,
+        "engines": "brave,bing",
+        "language": "en-US",
+        "time_range": "day",
+        "safe_search": 0,
+        "cache_ttl_seconds": 300,
+    }
+
+
+def test_sports_methods_build_expected_paths():
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
+    calls = []
+
+    def fake_fetch(path, **kwargs):
+        calls.append((path, kwargs))
+        return {"ok": True}
+
+    client._fetch = fake_fetch  # type: ignore[method-assign]
+    try:
+        assert client.sports_leagues()["ok"]
+        assert client.sports_games("nba", status="active", limit=2)["ok"]
+        assert client.sports_game("nba-nyk-cle-2026-05-25")["ok"]
+        assert client.sports_game_state(
+            "nba-nyk-cle-2026-05-25",
+            include_history=True,
+            price_limit_tokens=4,
+            history_limit_tokens=2,
+            interval="1d",
+        )["ok"]
+        assert client.sports_game_context(
+            "nba-nyk-cle-2026-05-25",
+            sources=["x", "online"],
+            query_set="injuries",
+            max_queries=2,
+            max_per_query=3,
+            include_state=True,
+            price_limit_tokens=4,
+        )["ok"]
+        assert client.sports_game_prices("nba-nyk-cle-2026-05-25", limit_tokens=4)["ok"]
+        assert client.sports_game_history("nba-nyk-cle-2026-05-25", interval="1d", limit_tokens=2)["ok"]
+    finally:
+        client.close()
+
+    assert calls[0][0] == "/v2/sports/leagues"
+    assert calls[1][0] == "/v2/sports/leagues/nba/games"
+    assert calls[1][1]["query"] == {"status": "active", "limit": 2, "offset": None, "sort": None, "direction": None}
+    assert calls[2][0] == "/v2/sports/games/nba-nyk-cle-2026-05-25"
+    assert calls[3][0] == "/v2/sports/games/nba-nyk-cle-2026-05-25/state"
+    assert calls[3][1]["query"]["include_history"] is True
+    assert calls[3][1]["query"]["price_limit_tokens"] == 4
+    assert calls[3][1]["query"]["history_limit_tokens"] == 2
+    assert calls[4][0] == "/v2/sports/games/nba-nyk-cle-2026-05-25/context"
+    assert calls[4][1]["query"] == {
+        "sources": "x,online",
+        "query_set": "injuries",
+        "max_queries": 2,
+        "max_per_query": 3,
+        "include_state": True,
+        "price_limit_tokens": 4,
+    }
+    assert calls[5][0] == "/v2/sports/games/nba-nyk-cle-2026-05-25/prices"
+    assert calls[5][1]["query"] == {"limit_tokens": 4}
+    assert calls[6][0] == "/v2/sports/games/nba-nyk-cle-2026-05-25/history"
+    assert calls[6][1]["query"]["interval"] == "1d"
+    assert calls[6][1]["query"]["limit_tokens"] == 2

{polynode-0.10.4 → polynode-0.10.6}/tests/test_orderbook.py

@@ -1,7 +1,7 @@
 """Tests for LocalOrderbook state management."""
 
 from polynode.orderbook_state import LocalOrderbook
-from polynode.types.orderbook import BookSnapshot, BookUpdate, OrderbookLevel
+from polynode.types.orderbook import BookSnapshot, BookUpdate, OrderbookLevel, PriceChange, PriceChangeAsset
 
 
 def test_apply_snapshot():
@@ -57,3 +57,17 @@ def test_spread():
     spread = ob.get_spread("t1")
     assert spread is not None
     assert abs(spread - 0.10) < 0.001
+
+
+def test_apply_price_change_tracks_last_price():
+    ob = LocalOrderbook()
+    change = PriceChange(
+        market="m1",
+        assets=[PriceChangeAsset(asset_id="t1", price="0.57", outcome="Yes")],
+    )
+    ob.apply_price_change(change)
+
+    last = ob.get_last_price("t1")
+    assert last is not None
+    assert last.price == "0.57"
+    assert last.outcome == "Yes"

polynode-0.10.6/tests/test_orderbook_protocol.py

@@ -0,0 +1,131 @@
+"""Protocol-level orderbook WebSocket regression tests."""
+
+import asyncio
+import json
+
+import pytest
+
+from polynode.errors import WsError
+from polynode.orderbook import OrderbookWS
+
+
+class FakeSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict] = []
+
+    async def send(self, data: str) -> None:
+        self.sent.append(json.loads(data))
+
+
+def snapshot(asset_id: str = "token-1") -> dict:
+    return {
+        "type": "book_snapshot",
+        "asset_id": asset_id,
+        "market": "condition-1",
+        "bids": [{"price": "0.50", "size": "100"}],
+        "asks": [{"price": "0.55", "size": "200"}],
+    }
+
+
+def make_ws(timeout: float = 0.2) -> tuple[OrderbookWS, FakeSocket]:
+    socket = FakeSocket()
+    ws = OrderbookWS("key", "wss://example.test/ws", subscribe_timeout=timeout)
+    ws._socket = socket
+    ws._connected = True
+    return ws, socket
+
+
+def test_orderbook_subscribe_waits_for_ack_without_dropping_snapshots():
+    async def scenario() -> None:
+        ws, socket = make_ws()
+        snapshots = []
+        subscribed = []
+        ws.on("snapshot", snapshots.append)
+        ws.on("subscribed", subscribed.append)
+
+        task = asyncio.create_task(ws.subscribe(["token-1"]))
+        await asyncio.sleep(0)
+
+        assert socket.sent == [{"action": "subscribe", "markets": ["token-1"]}]
+        assert not task.done()
+
+        ws._handle_message(json.dumps({"type": "snapshot_batch", "snapshots": [snapshot()]}))
+        assert len(snapshots) == 1
+        assert not task.done()
+
+        ws._handle_message(json.dumps({"type": "subscribed", "markets": 1}))
+        await asyncio.wait_for(task, timeout=0.1)
+
+        assert subscribed[0].markets == 1
+        assert snapshots[0].asset_id == "token-1"
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_subscribe_rejects_server_error_before_ack():
+    async def scenario() -> None:
+        ws, _ = make_ws()
+        errors = []
+        ws.on("error", errors.append)
+
+        task = asyncio.create_task(ws.subscribe(["token-1", "token-2"]))
+        await asyncio.sleep(0)
+        ws._handle_message(
+            json.dumps(
+                {
+                    "error": "too_many_markets",
+                    "message": "Too many markets",
+                    "max": 1,
+                    "requested": 2,
+                }
+            )
+        )
+
+        with pytest.raises(WsError, match="Too many markets"):
+            await task
+
+        assert errors[0].error == "too_many_markets"
+        assert errors[0].max == 1
+        assert errors[0].requested == 2
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_subscribe_timeout_uses_configured_timeout():
+    async def scenario() -> None:
+        ws, socket = make_ws(timeout=0.01)
+
+        with pytest.raises(WsError, match="0.01 seconds"):
+            await ws.subscribe(["token-1"])
+
+        assert socket.sent == [{"action": "subscribe", "markets": ["token-1"]}]
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_partial_unsubscribe_is_additive():
+    async def scenario() -> None:
+        ws, socket = make_ws()
+        ws._token_ids = ["token-1", "token-2", "token-3"]
+
+        ws.unsubscribe(["token-2"])
+        await asyncio.sleep(0)
+
+        assert ws._token_ids == ["token-1", "token-3"]
+        assert socket.sent == [{"action": "unsubscribe", "markets": ["token-2"]}]
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_type_error_rejects_pending_subscribe():
+    async def scenario() -> None:
+        ws, _ = make_ws()
+        task = asyncio.create_task(ws.subscribe(["token-1"]))
+        await asyncio.sleep(0)
+
+        ws._handle_message(json.dumps({"type": "error", "code": "bad_request", "message": "Invalid token"}))
+
+        with pytest.raises(WsError, match="Invalid token"):
+            await task
+
+    asyncio.run(scenario())

polynode-0.10.6/tests/test_ws_protocol.py

@@ -0,0 +1,107 @@
+"""Protocol-level WebSocket regression tests."""
+
+import asyncio
+import json
+
+import pytest
+
+from polynode.errors import WsError
+from polynode.subscription import Subscription
+from polynode.types.ws import SubscriptionFilters, WsOptions
+from polynode.ws import PolyNodeWS
+
+
+class FakeSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict] = []
+
+    async def send(self, data: str) -> None:
+        self.sent.append(json.loads(data))
+
+
+def settlement_payload(tx_hash: str = "0xabc") -> dict:
+    return {
+        "event_type": "settlement",
+        "tx_hash": tx_hash,
+        "status": "pending",
+        "detected_at": 1234567890.0,
+        "taker_wallet": "0x123",
+        "taker_token": "0x456",
+        "taker_side": "BUY",
+        "taker_price": 0.55,
+        "taker_size": 100.0,
+        "trades": [],
+    }
+
+
+def test_snapshot_before_subscribed_is_replayed_to_late_handler():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "settlements", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._handle_message(json.dumps({"type": "snapshot", "events": [{"data": settlement_payload()}]}))
+        assert not fut.done()
+
+        ws._handle_message(json.dumps({"type": "subscribed", "subscription_id": "sub-1"}))
+        returned = await asyncio.wait_for(fut, timeout=0.1)
+
+        replayed = []
+        returned.on("settlement", replayed.append)
+
+        queued = await asyncio.wait_for(returned.__anext__(), timeout=0.1)
+        assert returned.id == "sub-1"
+        assert queued.tx_hash == "0xabc"
+        assert [event.tx_hash for event in replayed] == ["0xabc"]
+
+    asyncio.run(scenario())
+
+
+def test_pre_ack_snapshot_only_routes_to_compatible_pending_subscription():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "trades", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._handle_message(json.dumps({"type": "snapshot", "events": [{"data": settlement_payload()}]}))
+        ws._handle_message(json.dumps({"type": "subscribed", "subscription_id": "trade-sub"}))
+        await asyncio.wait_for(fut, timeout=0.1)
+
+        replayed = []
+        sub.on("*", replayed.append)
+        assert replayed == []
+        assert sub._queue.empty()
+
+    asyncio.run(scenario())
+
+
+def test_subscribe_timeout_uses_configured_timeout():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws", WsOptions(subscribe_timeout=0.01))
+        ws._socket = FakeSocket()
+        ws._connected = True
+
+        with pytest.raises(WsError, match="0.01 seconds"):
+            await ws.subscribe("settlements").send()
+
+        assert ws._socket.sent == [{"action": "subscribe", "type": "settlements"}]
+
+    asyncio.run(scenario())
+
+
+def test_disconnect_rejects_pending_subscriptions():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "settlements", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._reject_pending(WsError("closed"))
+
+        with pytest.raises(WsError, match="closed"):
+            await fut
+        assert ws._pending == []
+
+    asyncio.run(scenario())

polynode-0.10.4/polynode/_version.py

@@ -1 +0,0 @@
-__version__ = "0.9.1"

polynode-0.10.4/tests/test_client.py

@@ -1,45 +0,0 @@
-"""Tests for the sync REST client."""
-
-import pytest
-from polynode import PolyNode
-from polynode.types.rest import StatusResponse, MarketsResponse, SettlementsResponse
-
-TEST_KEY = "pn_live_test_session_tracking_51eca107e9b347b589f5b0a04f98eb1d"
-
-
-@pytest.fixture
-def pn():
-    client = PolyNode(api_key=TEST_KEY)
-    yield client
-    client.close()
-
-
-def test_healthz(pn):
-    result = pn.healthz()
-    assert result == "ok" or "ok" in str(result).lower()
-
-
-def test_status(pn):
-    result = pn.status()
-    assert isinstance(result, StatusResponse)
-    assert result.uptime_seconds > 0
-    assert result.state.market_count > 0
-
-
-def test_markets(pn):
-    result = pn.markets(count=3)
-    assert isinstance(result, MarketsResponse)
-    assert result.count > 0
-    assert len(result.markets) <= 3
-
-
-def test_recent_settlements(pn):
-    result = pn.recent_settlements(count=1)
-    assert isinstance(result, SettlementsResponse)
-    assert result.count >= 0
-
-
-def test_search(pn):
-    result = pn.search("election", limit=3)
-    assert result.query == "election"
-    assert result.count >= 0