hyperquant 1.35__tar.gz → 1.37__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.35
+Version: 1.37
 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.37}/pyproject.toml

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

{hyperquant-1.35 → hyperquant-1.37}/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.37}/src/hyperquant/broker/polymarket.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress
-from datetime import UTC, datetime
+from datetime import UTC, datetime, timedelta
 from functools import lru_cache
 import os
 from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
@@ -12,6 +12,7 @@ import json
 import aiohttp
 import pybotters
 import pybotters.ws
+import pytz
 
 from .models.polymarket import PolymarketDataStore
 from .auth import Auth
@@ -22,6 +23,7 @@ GAMMA_EVENTS_API = "https://gamma-api.polymarket.com/events"
 DEFAULT_DATA_ENDPOINT = "https://data-api.polymarket.com"
 RTS_DATA_ENDPOINT = "wss://ws-live-data.polymarket.com/"
 DEFAULT_BASE_SLUG = "btc-updown-15m"
+HOURLY_BITCOIN_BASE_SLUG = "bitcoin-up-or-down"
 DEFAULT_INTERVAL = 15 * 60
 DEFAULT_WINDOW = 8
 API_NAME = "polymarket"
@@ -38,6 +40,7 @@ DEFAULT_POLYGON_RPCS = (
     "https://polygon-rpc.com",
     "https://rpc.ankr.com/polygon",
 )
+_EASTERN_TZ = pytz.timezone("US/Eastern")
 
 def parse_field(value):
     """尝试将字符串 JSON 转为对象，否则原样返回"""
@@ -73,6 +76,21 @@ def _accepting_orders(market: Mapping[str, Any]) -> bool:
     return bool(accepting)
 
 
+def _compose_hourly_slug(base_slug: str, *, now: datetime | None = None) -> str:
+    tz_now = now or datetime.now(_EASTERN_TZ)
+    if tz_now.tzinfo is None:
+        tz_now = _EASTERN_TZ.localize(tz_now)
+    else:
+        tz_now = tz_now.astimezone(_EASTERN_TZ)
+
+    tz_now = (tz_now + timedelta(seconds=5)).replace(minute=0, second=0, microsecond=0)
+    month_str = tz_now.strftime("%B").lower()
+    day = tz_now.day
+    hour_12 = tz_now.strftime("%I").lstrip("0") or "0"
+    am_pm = tz_now.strftime("%p").lower()
+    return f"{base_slug}-{month_str}-{day}-{hour_12}{am_pm}-et"
+
+
 class Polymarket:
     """Polymarket CLOB client with REST helpers, stores and WS subscriptions."""
 
@@ -223,12 +241,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 +254,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
@@ -1170,6 +1189,33 @@ class Polymarket:
         https://docs.polymarket.com/api-reference/markets/get-market-by-id
         """
     
+        async def _try_slug(slug: str | None) -> tuple[str, dict, dict] | None:
+            if not slug:
+                return None
+            event = await self._fetch_event(slug)
+            if not event:
+                return None
+
+            event = {k: parse_field(v) for k, v in event.items()}
+            for market in event.get("markets", []):
+                if not _accepting_orders(market):
+                    continue
+                market = {k: parse_field(v) for k, v in market.items()}
+                return slug, event, market
+            return None
+
+        if base_slug == HOURLY_BITCOIN_BASE_SLUG:
+            hourly_slug = _compose_hourly_slug(base_slug)
+            hourly_match = await _try_slug(hourly_slug)
+            if hourly_match:
+                return hourly_match
+
+        # 1小时市场等特殊 slug（比如 bitcoin-up-or-down-november-18-10am-et）
+        # 直接传入完整 slug 即可，不再拼接时间戳
+        direct_match = await _try_slug(base_slug)
+        if direct_match:
+            return direct_match
+
         now_ts = int(datetime.now(UTC).timestamp())
         base_ts = (now_ts // interval) * interval
 
@@ -1178,18 +1224,9 @@ class Polymarket:
             if ts < 0:
                 continue
             slug = f"{base_slug}-{ts}"
-            event = await self._fetch_event(slug)
-            if not event:
-                continue
-
-
-            
-            event = {k: parse_field(v) for k, v in event.items()}
-
-            for market in event.get("markets", []):
-                if _accepting_orders(market):
-                    market = {k: parse_field(v) for k, v in market.items()}
-                    return slug, event, market
+            result = await _try_slug(slug)
+            if result:
+                return result
 
         raise RuntimeError(
             f"未在 {base_slug} 的 +/-{window} 个区间内找到可交易的市场"

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

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