polynode 0.10.4__tar.gz → 0.10.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.10.4
+Version: 0.10.5
 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.5}/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.5/polynode/_version.py

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

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

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

polynode-0.10.5/tests/test_client.py

@@ -0,0 +1,137 @@
+"""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
+
+
+def test_search_online_builds_expected_path():
+    client = PolyNode(api_key=TEST_KEY)
+    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)
+    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.5}/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.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