polynode 0.10.5__tar.gz → 0.10.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.10.5
+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

polynode-0.10.6/polynode/_version.py

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

{polynode-0.10.5 → 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.5 → 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.5 → 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.5 → 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.5 → polynode-0.10.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polynode"
-version = "0.10.5"
+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.5 → 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.5 → polynode-0.10.6}/tests/test_client.py

@@ -1,14 +1,18 @@
 """Tests for the sync REST client."""
 
+import os
+
 import pytest
 from polynode import PolyNode
 from polynode.types.rest import StatusResponse, MarketsResponse, SettlementsResponse
 
-TEST_KEY = "pn_live_test_session_tracking_51eca107e9b347b589f5b0a04f98eb1d"
+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()
@@ -46,7 +50,7 @@ def test_search(pn):
 
 
 def test_search_online_builds_expected_path():
-    client = PolyNode(api_key=TEST_KEY)
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
     calls = []
 
     def fake_fetch(path, **kwargs):
@@ -80,7 +84,7 @@ def test_search_online_builds_expected_path():
 
 
 def test_sports_methods_build_expected_paths():
-    client = PolyNode(api_key=TEST_KEY)
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
     calls = []
 
     def fake_fetch(path, **kwargs):

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.5/polynode/_version.py

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