polynode 0.5.5__py3-none-any.whl

polynode/types/rest.py

@@ -0,0 +1,376 @@
+"""REST API response models for the PolyNode SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from .enums import EventStatus
+
+
+# ── System ──
+
+
+class StateSummary(BaseModel):
+    market_count: int
+    wallet_count: int
+    metadata_count: int
+    events_buffered: int
+    events_processed: int
+    latest_block: int
+
+
+class StatusResponse(BaseModel):
+    node_connected: bool
+    uptime_seconds: float
+    stream_length: int
+    events_stream_length: int
+    pending_txs: int
+    ws_subscribers: int
+    firehose_connections: int
+    redis_memory: str
+    state: StateSummary
+
+
+class ApiKeyResponse(BaseModel):
+    api_key: str
+    name: str
+    rate_limit_per_minute: int
+    message: str
+
+
+# ── Markets ──
+
+
+class MarketSummary(BaseModel):
+    token_id: str | None = None
+    last_price: float | None = None
+    volume_24h: float = 0
+    trade_count_24h: int = 0
+    last_trade_at: float | None = None
+    question: str | None = None
+    slug: str | None = None
+    outcomes: list[str] | None = None
+    condition_id: str | None = None
+    end_date: str | None = None
+    category: str | None = None
+    market_type: str | None = None
+    image: str | None = None
+    icon: str | None = None
+    neg_risk: bool | None = None
+    created_at: str | None = None
+    active: bool | None = None
+    closed: bool | None = None
+    last_status: EventStatus | None = None
+
+
+class MarketsResponse(BaseModel):
+    count: int
+    total: int
+    markets: list[MarketSummary]
+
+
+class MarketsListResponse(BaseModel):
+    count: int
+    total: int
+    cursor: int | None = None
+    markets: list[MarketSummary]
+
+
+class SearchResponse(BaseModel):
+    query: str
+    count: int
+    results: list[MarketSummary]
+
+
+# ── Pricing ──
+
+
+class Candle(BaseModel):
+    timestamp: float
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+
+
+class CandlesResponse(BaseModel):
+    candles: list[Candle]
+    count: int
+    token_id: str
+    question: str | None = None
+    slug: str | None = None
+    resolution: str | None = None
+
+
+# ── Settlements ──
+
+
+class Settlement(BaseModel):
+    tx_hash: str
+    taker_side: str
+    taker_size: str
+    taker_price: str
+    taker_wallet: str
+    taker_token: str
+    timestamp: str
+    detected_at: str
+    status: str
+    outcome: str
+    market_title: str
+    market_slug: str
+    market_image: str
+    event_title: str
+    block_number: str
+    id: str
+    trades_json: str
+
+
+class SettlementsResponse(BaseModel):
+    count: int
+    settlements: list[Settlement]
+    wallet: str | None = None
+    token_id: str | None = None
+
+
+# ── Wallets ──
+
+
+class WalletActivity(BaseModel):
+    last_active: float
+    trade_count: int
+    trade_volume_usd: float
+    transfer_count: int
+    deposit_count: int
+    deposit_volume_usd: float
+
+
+class WalletResponse(BaseModel):
+    wallet: str
+    activity: WalletActivity
+
+    model_config = {"extra": "allow"}
+
+
+# ── Orderbook (REST) ──
+
+
+class OrderbookLevel(BaseModel):
+    price: str
+    size: str
+
+
+class OrderbookResponse(BaseModel):
+    bids: list[OrderbookLevel]
+    asks: list[OrderbookLevel]
+    asset_id: str
+    market: str
+    hash: str
+    last_trade_price: str
+    min_order_size: str
+    tick_size: str
+    neg_risk: bool
+    timestamp: str
+
+
+class MidpointResponse(BaseModel):
+    mid: str
+
+
+class SpreadResponse(BaseModel):
+    spread: str
+
+
+# ── Enriched Data ──
+
+
+class LeaderboardTrader(BaseModel):
+    rank: int
+    wallet: str
+    name: str
+    pnl: float
+    volume: float
+    profileImage: str | None = None
+
+
+class LeaderboardResponse(BaseModel):
+    traders: list[LeaderboardTrader]
+    period: str
+    sort: str
+    count: int
+
+
+class TrendingCarouselItem(BaseModel):
+    id: str
+    slug: str
+    title: str
+    image: str | None = None
+    volume: float
+    volume24hr: float | None = None
+    liquidity: float | None = None
+    startDate: str
+    active: bool
+    closed: bool
+
+
+class TrendingBreakingItem(BaseModel):
+    id: str
+    slug: str
+    question: str
+    image: str | None = None
+    outcomePrices: list[str]
+    oneDayPriceChange: float
+
+
+class TrendingHotTopic(BaseModel):
+    title: str
+    volume: float
+    url: str
+
+
+class TrendingResponse(BaseModel):
+    carousel: list[TrendingCarouselItem]
+    breaking: list[TrendingBreakingItem]
+    hotTopics: list[TrendingHotTopic]
+    featured: list[TrendingCarouselItem]
+    movers: list[TrendingBreakingItem]
+
+
+class ActivityTrade(BaseModel):
+    wallet: str
+    side: str
+    tokenId: str
+    conditionId: str
+    size: float
+    price: float
+    timestamp: float
+    title: str
+    slug: str
+    eventSlug: str
+    outcome: str
+    name: str
+    txHash: str
+
+
+class ActivityResponse(BaseModel):
+    trades: list[ActivityTrade]
+    count: int
+
+
+class MoverMarket(BaseModel):
+    id: str
+    slug: str
+    question: str
+    image: str | None = None
+    outcomePrices: list[str]
+    oneDayPriceChange: float
+
+
+class MoversResponse(BaseModel):
+    markets: list[MoverMarket]
+    count: int
+
+
+class TraderProfile(BaseModel):
+    wallet: str
+    name: str
+    pseudonym: str
+    profileSlug: str
+    joinDate: str
+    trades: int
+    marketsTraded: int
+    largestWin: float
+    views: int
+    totalVolume: float
+    totalPnl: float
+    realizedPnl: float
+    unrealizedPnl: float
+    positionValue: float
+    profileImage: str | None = None
+
+
+class PnlPoint(BaseModel):
+    timestamp: float
+    pnl: float
+
+
+class TraderPnlResponse(BaseModel):
+    wallet: str
+    period: str
+    series: list[PnlPoint]
+    count: int
+
+
+class EventMarket(BaseModel):
+    question: str
+    conditionId: str
+    outcomes: list[str]
+    outcomePrices: list[str]
+    volume: float
+    liquidity: float
+    active: bool
+    closed: bool
+    groupItemTitle: str | None = None
+    tokenId: str | None = None
+
+
+class EventSearchMarket(BaseModel):
+    question: str
+    groupItemTitle: str
+    conditionId: str
+    tokenId: str | None = None
+    price: float | None = None
+    active: bool
+
+
+class EventSearchResult(BaseModel):
+    id: str
+    slug: str
+    title: str
+    image: str | None = None
+    active: bool
+    markets: list[EventSearchMarket]
+
+
+class EventSearchResponse(BaseModel):
+    query: str
+    events: list[EventSearchResult]
+    count: int
+
+
+class EventDetailResponse(BaseModel):
+    id: int
+    slug: str
+    title: str
+    description: str
+    image: str | None = None
+    active: bool
+    closed: bool
+    volume: float
+    volume24hr: float
+    liquidity: float
+    startDate: str
+    endDate: str
+    markets: list[EventMarket]
+    series: dict[str, Any] | None = None
+    similarMarkets: int
+    annotations: int
+
+
+class MarketsByCategoryResponse(BaseModel):
+    category: str
+    counts: dict[str, int]
+    events: list[dict[str, Any]]
+    totalResults: int
+
+
+# ── RPC ──
+
+
+class JsonRpcResponse(BaseModel):
+    jsonrpc: str
+    id: int | str | None = None
+    result: Any | None = None
+    error: dict[str, Any] | None = None

polynode/types/short_form.py

@@ -0,0 +1,35 @@
+"""Short-form market types for the PolyNode SDK."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+ShortFormInterval = Literal["5m", "15m", "1h"]
+ShortFormCoin = Literal["btc", "eth", "sol", "xrp", "doge", "hype", "bnb"]
+
+
+class ShortFormMarket(BaseModel):
+    coin: ShortFormCoin
+    slug: str
+    title: str
+    condition_id: str
+    window_start: int
+    window_end: int
+    outcomes: list[str]
+    outcome_prices: list[float]
+    clob_token_ids: list[str]
+    up_odds: float
+    down_odds: float
+    liquidity: float
+    volume_24h: float
+    price_to_beat: float | None = None
+
+
+class RotationEvent(BaseModel):
+    interval: ShortFormInterval
+    markets: list[ShortFormMarket]
+    window_start: int
+    window_end: int
+    time_remaining: int

polynode/types/ws.py

@@ -0,0 +1,38 @@
+"""WebSocket protocol types for the PolyNode SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .enums import EventType, SubscriptionType
+
+
+@dataclass
+class SubscriptionFilters:
+    wallets: list[str] | None = None
+    tokens: list[str] | None = None
+    slugs: list[str] | None = None
+    condition_ids: list[str] | None = None
+    side: str | None = None
+    status: str | None = None
+    min_size: float | None = None
+    max_size: float | None = None
+    event_types: list[EventType] | None = None
+    snapshot_count: int | None = None
+    feeds: list[str] | None = None
+
+    def to_dict(self) -> dict:
+        d = {}
+        for k, v in self.__dict__.items():
+            if v is not None:
+                d[k] = v
+        return d
+
+
+@dataclass
+class WsOptions:
+    compress: bool = True
+    auto_reconnect: bool = True
+    max_reconnect_attempts: int = 0  # 0 = infinite
+    reconnect_base_delay: float = 1.0
+    reconnect_max_delay: float = 30.0

polynode/ws.py

@@ -0,0 +1,278 @@
+"""Async WebSocket client for PolyNode settlement and market event streaming."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+import random
+import zlib
+from typing import Any, Callable
+
+import websockets
+import websockets.asyncio.client
+
+from .errors import WsError
+from .subscription import Subscription, SubscriptionBuilder
+from .types.enums import SubscriptionType
+from .types.events import PolyNodeEvent
+from .types.ws import SubscriptionFilters, WsOptions
+
+
+def _parse_event(data: dict) -> PolyNodeEvent | None:
+    """Parse a raw dict into a typed PolyNodeEvent using Pydantic."""
+    from pydantic import TypeAdapter
+    _adapter = TypeAdapter(PolyNodeEvent)
+    try:
+        return _adapter.validate_python(data)
+    except Exception:
+        return None
+
+
+class PolyNodeWS:
+    """Async WebSocket client with auto-reconnect and subscription management."""
+
+    def __init__(self, api_key: str, ws_url: str, options: WsOptions | None = None) -> None:
+        self._api_key = api_key
+        self._ws_url = ws_url
+        opts = options or WsOptions()
+        self._compress = opts.compress
+        self._auto_reconnect = opts.auto_reconnect
+        self._max_reconnect = opts.max_reconnect_attempts
+        self._base_delay = opts.reconnect_base_delay
+        self._max_delay = opts.reconnect_max_delay
+
+        self._socket: Any = None
+        self._connected = False
+        self._intentional_close = False
+        self._reconnect_attempts = 0
+        self._sub_counter = 0
+        self._subscriber_id: str | None = None
+
+        self._subscriptions: dict[str, Subscription] = {}
+        self._pending: list[tuple[Subscription, asyncio.Future]] = []
+
+        self._recv_task: asyncio.Task | None = None
+
+        # System handlers
+        self._on_connect: list[Callable] = []
+        self._on_disconnect: list[Callable] = []
+        self._on_reconnect: list[Callable] = []
+        self._on_error: list[Callable] = []
+        self._on_heartbeat: list[Callable] = []
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected
+
+    def on_connect(self, handler: Callable) -> PolyNodeWS:
+        self._on_connect.append(handler)
+        return self
+
+    def on_disconnect(self, handler: Callable) -> PolyNodeWS:
+        self._on_disconnect.append(handler)
+        return self
+
+    def on_reconnect(self, handler: Callable) -> PolyNodeWS:
+        self._on_reconnect.append(handler)
+        return self
+
+    def on_error(self, handler: Callable) -> PolyNodeWS:
+        self._on_error.append(handler)
+        return self
+
+    def on_heartbeat(self, handler: Callable) -> PolyNodeWS:
+        self._on_heartbeat.append(handler)
+        return self
+
+    def subscribe(self, type: SubscriptionType) -> SubscriptionBuilder:
+        return SubscriptionBuilder(self, type)
+
+    async def _subscribe(self, type: SubscriptionType, filters: SubscriptionFilters) -> Subscription:
+        await self._ensure_connected()
+
+        sub = Subscription(self, type, filters)
+        fut: asyncio.Future[Subscription] = asyncio.get_event_loop().create_future()
+        self._pending.append((sub, fut))
+
+        msg: dict[str, Any] = {"action": "subscribe"}
+        if type:
+            msg["type"] = type
+        clean_filters = filters.to_dict()
+        if clean_filters:
+            msg["filters"] = clean_filters
+
+        await self._send(json.dumps(msg))
+
+        try:
+            return await asyncio.wait_for(fut, timeout=10.0)
+        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")
+
+    def _unsubscribe(self, subscription_id: str | None = None) -> None:
+        if subscription_id:
+            self._subscriptions.pop(subscription_id, None)
+            if self._connected and self._socket:
+                asyncio.ensure_future(
+                    self._send(json.dumps({"action": "unsubscribe", "subscription_id": subscription_id}))
+                )
+        else:
+            self._subscriptions.clear()
+            if self._connected and self._socket:
+                asyncio.ensure_future(self._send(json.dumps({"action": "unsubscribe"})))
+
+    def unsubscribe_all(self) -> None:
+        self._unsubscribe()
+
+    async def connect(self) -> None:
+        if self._connected and self._socket:
+            return
+        await self._connect()
+
+    def disconnect(self) -> None:
+        self._intentional_close = True
+        if self._recv_task and not self._recv_task.done():
+            self._recv_task.cancel()
+        if self._socket:
+            asyncio.ensure_future(self._socket.close())
+            self._socket = None
+        self._connected = False
+
+    # ── Private ──
+
+    async def _ensure_connected(self) -> None:
+        if not self._connected or not self._socket:
+            await self._connect()
+
+    async def _connect(self) -> None:
+        url = f"{self._ws_url}?key={self._api_key}"
+        if self._compress:
+            url += "&compress=zlib"
+
+        self._socket = await websockets.asyncio.client.connect(url, max_size=10 * 1024 * 1024)
+        self._connected = True
+        self._reconnect_attempts = 0
+        self._intentional_close = False
+
+        for h in self._on_connect:
+            h()
+
+        self._recv_task = asyncio.ensure_future(self._recv_loop())
+
+    async def _recv_loop(self) -> None:
+        try:
+            async for raw in self._socket:
+                try:
+                    if isinstance(raw, bytes) and self._compress:
+                        text = zlib.decompress(raw, -zlib.MAX_WBITS).decode("utf-8")
+                    elif isinstance(raw, bytes):
+                        text = raw.decode("utf-8")
+                    else:
+                        text = raw
+                    self._handle_message(text)
+                except Exception as e:
+                    err = WsError(f"Failed to process message: {e}")
+                    for h in self._on_error:
+                        h(err)
+        except websockets.exceptions.ConnectionClosed:
+            pass
+        except asyncio.CancelledError:
+            return
+        finally:
+            self._connected = False
+            reason = "closed" if self._intentional_close else "lost"
+            for h in self._on_disconnect:
+                h(reason)
+            if not self._intentional_close and self._auto_reconnect:
+                asyncio.ensure_future(self._schedule_reconnect())
+
+    async def _send(self, data: str) -> None:
+        if self._socket and self._connected:
+            await self._socket.send(data)
+
+    def _handle_message(self, text: str) -> None:
+        msg = json.loads(text)
+        msg_type = msg.get("type")
+
+        if msg_type == "subscribed":
+            sub_id = msg.get("subscription_id", "")
+            self._subscriber_id = msg.get("subscriber_id") or self._subscriber_id
+            if self._pending:
+                sub, fut = self._pending.pop(0)
+                sub._set_id(sub_id)
+                self._subscriptions[sub_id] = sub
+                if not fut.done():
+                    fut.set_result(sub)
+
+        elif msg_type == "heartbeat":
+            ts = msg.get("ts", 0)
+            for h in self._on_heartbeat:
+                h(ts)
+
+        elif msg_type == "pong":
+            pass
+
+        elif msg_type == "error":
+            err = WsError(msg.get("message", "Unknown error"), msg.get("code"))
+            for h in self._on_error:
+                h(err)
+            if self._pending:
+                sub, fut = self._pending.pop(0)
+                if not fut.done():
+                    fut.set_exception(err)
+
+        elif msg_type == "snapshot":
+            events = msg.get("events", [])
+            for wrapper in events:
+                data = wrapper.get("data")
+                if data:
+                    event = _parse_event(data)
+                    if event:
+                        self._route_event(event)
+
+        elif msg_type == "unsubscribed":
+            pass
+
+        else:
+            data = msg.get("data")
+            if data and data.get("event_type"):
+                event = _parse_event(data)
+                if event:
+                    self._route_event(event)
+
+    def _route_event(self, event: PolyNodeEvent) -> None:
+        for sub in self._subscriptions.values():
+            sub._emit(event)
+
+    async def _schedule_reconnect(self) -> None:
+        if self._max_reconnect and self._reconnect_attempts >= self._max_reconnect:
+            return
+
+        self._reconnect_attempts += 1
+        delay = min(self._base_delay * math.pow(2, self._reconnect_attempts - 1), self._max_delay)
+        jitter = delay * (0.5 + random.random() * 0.5)
+
+        await asyncio.sleep(jitter)
+
+        try:
+            await self._connect()
+            for h in self._on_reconnect:
+                h(self._reconnect_attempts)
+            await self._resubscribe_all()
+        except Exception:
+            pass
+
+    async def _resubscribe_all(self) -> None:
+        existing = list(self._subscriptions.items())
+        self._subscriptions.clear()
+
+        for _, sub in existing:
+            try:
+                new_sub = await self._subscribe(sub.type, sub.filters)
+                if new_sub.id:
+                    self._subscriptions[new_sub.id] = sub
+                    sub._set_id(new_sub.id)
+            except Exception:
+                pass