hyperquant 1.35__tar.gz → 1.36__tar.gz

{hyperquant-1.35 → hyperquant-1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.35
+Version: 1.36
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-1.35 → hyperquant-1.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.35"
+version = "1.36"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.35 → hyperquant-1.36}/src/hyperquant/broker/models/polymarket.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import json
+from dataclasses import dataclass, field
+from heapq import heappop, heappush
 from typing import TYPE_CHECKING, Any, Iterable
 
 from pybotters.store import DataStore, DataStoreCollection
@@ -332,6 +334,163 @@ class Book(DataStore):
             limit=limit,
         )
 
+@dataclass
+class _SideBook:
+    is_ask: bool
+    levels: dict[float, tuple[str, str]] = field(default_factory=dict)
+    heap: list[tuple[float, float]] = field(default_factory=list)
+
+    def clear(self) -> None:
+        self.levels.clear()
+        self.heap.clear()
+
+    def update_levels(
+        self, updates: Iterable[dict[str, Any]] | None, *, snapshot: bool
+    ) -> None:
+        if updates is None:
+            return
+
+        if snapshot:
+            self.clear()
+
+        for entry in updates:
+            price, size = self._extract(entry)
+            price_val = self._to_float(price)
+            size_val = self._to_float(size)
+            if price_val is None or size_val is None:
+                continue
+
+            if size_val <= 0:
+                self.levels.pop(price_val, None)
+                continue
+
+            self.levels[price_val] = (str(price), str(size))
+            priority = price_val if self.is_ask else -price_val
+            heappush(self.heap, (priority, price_val))
+
+    def best(self) -> tuple[str, str] | None:
+        while self.heap:
+            _, price = self.heap[0]
+            level = self.levels.get(price)
+            if level is not None:
+                return level
+            heappop(self.heap)
+        return None
+
+    @staticmethod
+    def _extract(entry: Any) -> tuple[Any, Any]:
+        if isinstance(entry, dict):
+            price = entry.get("price", entry.get("p"))
+            size = entry.get("size", entry.get("q"))
+            return price, size
+        if isinstance(entry, (list, tuple)) and len(entry) >= 2:
+            return entry[0], entry[1]
+        return None, None
+
+    @staticmethod
+    def _to_float(value: Any) -> float | None:
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return None
+
+
+class BBO(DataStore):
+    _KEYS = ["s", "S"]
+
+    def _init(self) -> None:
+        self._book: dict[str, dict[str, _SideBook]] = {}
+        self.id_to_alias: dict[str, str] = {}
+
+    def update_aliases(self, mapping: dict[str, str]) -> None:
+        if not mapping:
+            return
+        self.id_to_alias.update(mapping)
+
+    def _alias(self, asset_id: str | None) -> tuple[str, str | None] | tuple[None, None]:
+        if asset_id is None:
+            return None, None
+        alias = self.id_to_alias.get(asset_id)
+        return asset_id, alias
+
+    def _side(self, symbol: str, side: str) -> _SideBook:
+        symbol_book = self._book.setdefault(symbol, {})
+        side_book = symbol_book.get(side)
+        if side_book is None:
+            side_book = _SideBook(is_ask=(side == "a"))
+            symbol_book[side] = side_book
+        return side_book
+
+    def _sync_side(
+        self, symbol: str, side: str, best: tuple[str, str] | None, alias: str | None
+    ) -> None:
+        key = {"s": symbol, "S": side}
+        current = self.get(key)
+
+        if best is None:
+            if current:
+                self._delete([key])
+            return
+
+        price, size = best
+        payload = {"s": symbol, "S": side, "p": price, "q": size}
+        if alias is not None:
+            payload["alias"] = alias
+
+        if current:
+            cur_price = current.get("p")
+            cur_size = current.get("q")
+            cur_alias = current.get("alias")
+
+            if cur_price == price:
+                # price unchanged -> only update quantities / alias changes
+                if cur_size != size or (alias is not None and cur_alias != alias):
+                    self._update([payload])
+                return
+
+            # price changed -> delete old then insert new level to trigger change watchers
+            self._delete([key])
+
+        self._insert([payload])
+
+    def _from_price_changes(self, msg: dict[str, Any]) -> None:
+        price_changes = msg.get("price_changes") or []
+        touched: dict[str, str | None] = {}
+        for change in price_changes:
+            asset_id = change.get("asset_id") or change.get("token_id")
+            symbol, alias = self._alias(asset_id)
+            if symbol is None:
+                continue
+            side = "b" if str(change.get("side") or "").upper() == "BUY" else "a"
+            side_book = self._side(symbol, side)
+            side_book.update_levels([change], snapshot=False)
+            touched[symbol] = alias
+
+        for symbol, alias in touched.items():
+            asks = self._side(symbol, "a")
+            bids = self._side(symbol, "b")
+            self._sync_side(symbol, "a", asks.best(), alias)
+            self._sync_side(symbol, "b", bids.best(), alias)
+
+    def _from_snapshot(self, msg: dict[str, Any]) -> None:
+        asset_id = msg.get("asset_id") or msg.get("token_id")
+        symbol, alias = self._alias(asset_id)
+        if symbol is None:
+            return
+        asks = self._side(symbol, "a")
+        bids = self._side(symbol, "b")
+        asks.update_levels(msg.get("asks"), snapshot=True)
+        bids.update_levels(msg.get("bids"), snapshot=True)
+        self._sync_side(symbol, "a", asks.best(), alias)
+        self._sync_side(symbol, "b", bids.best(), alias)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        msg_type = (msg.get("event_type") or msg.get("type") or "").lower()
+        if msg_type == "book":
+            self._from_snapshot(msg)
+        elif msg_type == "price_change":
+            self._from_price_changes(msg)
+
 
 class Detail(DataStore):
     """Market metadata keyed by Polymarket token id."""
@@ -446,6 +605,7 @@ class PolymarketDataStore(DataStoreCollection):
 
     def _init(self) -> None:
         self._create("book", datastore_class=Book)
+        self._create("bbo", datastore_class=BBO)
         self._create("detail", datastore_class=Detail)
         self._create("position", datastore_class=Position)
         self._create("order", datastore_class=Order)
@@ -627,6 +787,14 @@ class PolymarketDataStore(DataStoreCollection):
 
         return self._get("fill")
     
+    @property
+    def bbo(self) -> BBO:
+        """Best Bid and Offer DataStore
+        _key: s (asset_id), S (side)
+
+        """
+        return self._get("bbo")
+    
     @property
     def trade(self) -> Trade:
         """
@@ -683,3 +851,14 @@ class PolymarketDataStore(DataStoreCollection):
                 self.position.on_trade(m)
             elif msg_type == 'orders_matched':
                 self.trade._on_message(m)
+    
+    def onmessage_for_bbo(self, msg: Any, ws: ClientWebSocketResponse | None = None) -> None:
+        # 判定msg是否为list
+        lst_msg = msg if isinstance(msg, list) else [msg]
+        for m in lst_msg:
+            raw_type = m.get("event_type") or m.get("type")
+            if not raw_type:
+                continue
+            msg_type = str(raw_type).lower()
+            if msg_type in {"book", "price_change"}:
+                self.bbo._on_message(m)

{hyperquant-1.35 → hyperquant-1.36}/src/hyperquant/broker/polymarket.py

@@ -223,12 +223,12 @@ class Polymarket:
             self.store.orders._on_response(orders)
 
 
-        
 
     async def sub_books(
         self,
         token_ids: Sequence[str] | str,
         wsapp: pybotters.ws.WebSocketApp | None = None,
+        only_bbo: bool = False,
     ) -> pybotters.ws.WebSocketApp:
         """Subscribe to public order-book updates for the provided token ids."""
 
@@ -236,11 +236,12 @@ class Polymarket:
         payload = {"type": "market", "assets_ids": tokens}
         if wsapp:
             await wsapp.current_ws.send_json(payload)
-        
+        hdrl_json = self.store.onmessage_for_bbo if only_bbo else self.store.onmessage
+
         self._ws_public = self.client.ws_connect(
             self.ws_public,
             send_json=payload,
-            hdlr_json=self.store.onmessage,
+            hdlr_json=hdrl_json,
         )
         await self._ws_public._event.wait()
         return self._ws_public

{hyperquant-1.35 → hyperquant-1.36}/uv.lock

@@ -945,7 +945,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.34"
+version = "1.35"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },