hyperquant 1.34__tar.gz → 1.36__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.34
+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.34 → hyperquant-1.36}/pyproject.toml

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

{hyperquant-1.34 → hyperquant-1.36}/src/hyperquant/broker/auth.py

@@ -499,9 +499,67 @@ class Auth:
         if not creds:
             return args
 
+        if isinstance(creds, tuple):
+            creds = list(creds)
+            session.__dict__["_apis"][api_name] = creds
+
         private_key = creds[0] if len(creds) > 0 and creds[0] else None
-        chain_id = session.__dict__.get("_polymarket_chain_id", 137)
-        api_meta = session.__dict__.get("_polymarket_api_creds", {})
+        if private_key:
+            pk_str = str(private_key)
+            if not pk_str.startswith("0x"):
+                pk_str = f"0x{pk_str}"
+                try:
+                    session.__dict__["_apis"][api_name][0] = pk_str
+                except Exception:
+                    pass
+            private_key = pk_str
+
+        packed_extra = creds[2] if len(creds) > 2 else None
+        packed_api_key = packed_api_secret = packed_passphrase = None
+        packed_chain_id = packed_wallet = None
+        if isinstance(packed_extra, (list, tuple)):
+            def _packed_value(idx: int):
+                if idx >= len(packed_extra):
+                    return None
+                value = packed_extra[idx]
+                if isinstance(value, str):
+                    value = value.strip()
+                return value or None
+
+            packed_api_key = _packed_value(0)
+            packed_api_secret = _packed_value(1)
+            packed_passphrase = _packed_value(2)
+            packed_chain_id = _packed_value(3)
+            packed_wallet = _packed_value(4)
+        elif isinstance(packed_extra, str):
+            packed_wallet = packed_extra or None
+
+        existing_chain_id = session.__dict__.get("_polymarket_chain_id")
+        if existing_chain_id is None:
+            chain_id = 137
+            if packed_chain_id is not None:
+                try:
+                    chain_id = int(packed_chain_id)
+                except (TypeError, ValueError):
+                    chain_id = 137
+            session.__dict__["_polymarket_chain_id"] = chain_id
+        else:
+            chain_id = existing_chain_id
+
+        api_meta = session.__dict__.get("_polymarket_api_creds") or {}
+        if (not api_meta.get("api_key") or not api_meta.get("api_secret") or not api_meta.get("api_passphrase")) and (
+            packed_api_key and packed_api_secret and packed_passphrase
+        ):
+            api_meta = {
+                "api_key": packed_api_key,
+                "api_secret": packed_api_secret,
+                "api_passphrase": packed_passphrase,
+            }
+            session.__dict__["_polymarket_api_creds"] = api_meta
+
+        if packed_wallet and len(creds) > 2 and isinstance(creds[2], (list, tuple)):
+            creds[2] = packed_wallet
+
         api_key = api_meta.get("api_key")
         api_secret = api_meta.get("api_secret")
         api_passphrase = api_meta.get("api_passphrase")

{hyperquant-1.34 → 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
@@ -18,6 +20,50 @@ class Position(DataStore):
     def _on_response(self, msg: Item) -> None:
         self._update(msg)
 
+    def on_trade(self, trade: Item) -> None:
+        status = str(trade.get("status") or "").upper()
+        if status not in {"MATCHED"}:
+            return
+
+        asset_id = trade.get("asset_id")
+        outcome = trade.get("outcome")
+        side = str(trade.get("side") or "").upper()
+        size_raw = trade.get("size")
+
+        if not asset_id or not outcome or side not in {"BUY", "SELL"}:
+            return
+
+        try:
+            size = float(size_raw)
+        except (TypeError, ValueError):
+            return
+
+        key = {"asset": asset_id, "outcome": outcome}
+        existing = self.get(key) or {}
+
+        cur_size = float(existing.get("size") or 0.0)
+        cur_total_bought = float(existing.get("totalBought") or 0.0)
+
+        if side == "BUY":
+            new_size = cur_size + size
+            total_bought = cur_total_bought + size
+        else:  # SELL
+            new_size = cur_size - size
+            total_bought = cur_total_bought
+
+        rec: dict[str, Any] = {
+            "asset": asset_id,
+            "outcome": outcome,
+            "side": side,
+            "size": new_size,
+            "totalBought": total_bought,
+        }
+
+        if existing:
+            self._update([rec])
+        else:
+            self._insert([rec])
+
 
 class Fill(DataStore):
     """Fill records keyed by maker order id."""
@@ -157,13 +203,17 @@ class MyTrade(DataStore):
 class Trade(DataStore):
     """User trades keyed by trade id."""
 
-    _KEYS = ["asset"]
+    _KEYS = ["asset_id"]
     _MAXLEN = 500
 
 
     def _on_message(self, msg: dict[str, Any]) -> None:
-        payload = msg.get("payload") or {}
+        payload = msg or {}
         if payload:
+            size = float(payload.get("size"))
+            price = float(payload.get("price"))
+            # share = size / price
+            # payload['shares'] = share
             self._insert([payload])
 
 class Book(DataStore):
@@ -284,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."""
@@ -398,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)
@@ -579,31 +787,47 @@ 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:
         """
         _key asset
-
+        MATCHED进行快速捕捉
         .. code:: json
             {
-                "asset": "28343900911859986062638672238388649192722581036873866155064320792236495661418",
-                "bio": "",
-                "conditionId": "0x730a593d5b63a39d316139a7f4bc1dd9fd05d858f6d96f659629c371bc81cd4d",
-                "eventSlug": "btc-updown-15m-1762951500",
-                "icon": "https://polymarket-upload.s3.us-east-2.amazonaws.com/BTC+fullsize.png",
-                "name": "",
-                "outcome": "Down",
-                "outcomeIndex": 1,
-                "price": 0.11,
-                "profileImage": "",
-                "proxyWallet": "0x7459f51304037Da66c47CeA58F078D7f603fD011",
-                "pseudonym": "",
-                "side": "SELL",
-                "size": 84,
-                "slug": "btc-updown-15m-1762951500",
-                "timestamp": 1762952057,
-                "title": "Bitcoin Up or Down - November 12, 7:45AM-8:00AM ET",
-                "transactionHash": "0x6853cab8901779c494fe15f0eb3350aebfb182125347ca67b8bd9706babbddca"
+                "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
+                "event_type": "trade",
+                "id": "28c4d2eb-bbea-40e7-a9f0-b2fdb56b2c2e",
+                "last_update": "1672290701",
+                "maker_orders": [
+                    {
+                    "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
+                    "matched_amount": "10",
+                    "order_id": "0xff354cd7ca7539dfa9c28d90943ab5779a4eac34b9b37a757d7b32bdfb11790b",
+                    "outcome": "YES",
+                    "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                    "price": "0.57"
+                    }
+                ],
+                "market": "0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af",
+                "matchtime": "1672290701",
+                "outcome": "YES",
+                "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                "price": "0.57",
+                "side": "BUY",
+                "size": "10",
+                "status": "MATCHED",
+                "taker_order_id": "0x06bc63e346ed4ceddce9efd6b3af37c8f8f440c92fe7da6b2d0f9e4ccbc50c42",
+                "timestamp": "1672290701",
+                "trade_owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                "type": "TRADE"
             }
         """
         return self._get("trade")
@@ -624,5 +848,17 @@ class PolymarketDataStore(DataStoreCollection):
             elif msg_type == "trade":
                 self.trade._on_message(m)
                 self.fill._on_trade(m)
+                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.34 → hyperquant-1.36}/src/hyperquant/broker/polymarket.py

@@ -4,6 +4,7 @@ import asyncio
 from contextlib import suppress
 from datetime import UTC, datetime
 from functools import lru_cache
+import os
 from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
 
 import json
@@ -38,6 +39,14 @@ DEFAULT_POLYGON_RPCS = (
     "https://rpc.ankr.com/polygon",
 )
 
+def parse_field(value):
+    """尝试将字符串 JSON 转为对象，否则原样返回"""
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
 
 def _iter_offsets(window: int) -> Iterator[int]:
     yield 0
@@ -94,7 +103,7 @@ class Polymarket:
         self._ws_personal: pybotters.ws.WebSocketApp | None = None
         self.auth = False
 
-        self._ensure_session_entry(private_key=private_key, funder=funder)
+        self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
 
     async def __aenter__(self) -> "Polymarket":
         if self.auth:
@@ -214,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."""
 
@@ -227,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
@@ -266,6 +276,7 @@ class Polymarket:
         self._ws_personal = self.client.ws_connect(
             "wss://ws-subscriptions-clob.polymarket.com/ws/user",
             hdlr_json=effective_cb,
+            heartbeat=30,
             auth=None,
         )
         await self._ws_personal._event.wait()
@@ -298,7 +309,7 @@ class Polymarket:
         wsapp = self.client.ws_connect(
             RTS_DATA_ENDPOINT,
             hdlr_str=callback,
-            heartbeat=5
+            heartbeat=30
         )
         await wsapp._event.wait()
         await wsapp.current_ws.send_json(payload)
@@ -314,9 +325,12 @@ class Polymarket:
         return await self._rest("GET", f"/markets/{market_id}")
 
     async def get_market_by_slug(self, slug: str) -> Any:
-        """Fetch a market using its human-readable slug."""
-        # https://gamma-api.polymarket.com/markets/slug/{slug}
-        return await self._rest("GET", f"/slug/{slug}", host='https://gamma-api.polymarket.com/markets')
+        """Fetch a market using its human-readable slug.
+        https://docs.polymarket.com/api-reference/markets/get-market-by-slug
+        """
+        market:dict = await self._rest("GET", f"/slug/{slug}", host='https://gamma-api.polymarket.com/markets')
+        market = {k: parse_field(v) for k, v in market.items()}
+        return market
     
     async def get_order_book(self, token_id: str) -> Any:
         return await self._rest("GET", "/book", params={"token_id": token_id})
@@ -1169,14 +1183,7 @@ class Polymarket:
             if not event:
                 continue
 
-            def parse_field(value):
-                """尝试将字符串 JSON 转为对象，否则原样返回"""
-                if isinstance(value, str):
-                    try:
-                        return json.loads(value)
-                    except json.JSONDecodeError:
-                        return value
-                return value
+
             
             event = {k: parse_field(v) for k, v in event.items()}
 
@@ -1316,6 +1323,7 @@ class Polymarket:
         *,
         private_key: str | None,
         funder: str | None,
+        chain_id: int | None,
     ) -> None:
         session = getattr(self.client, "_session", None)
         if session is None:
@@ -1328,27 +1336,66 @@ class Polymarket:
         if not entry and not private_key:
             return
 
+        packed = entry[2] if len(entry) > 2 else None
+        if not isinstance(packed, (list, tuple)):
+            packed = None
+
+        def _packed_value(idx: int) -> Any | None:
+            if packed is None:
+                return None
+            if idx >= len(packed):
+                return None
+            value = packed[idx]
+            if isinstance(value, str):
+                value = value.strip()
+            return value or None
+
+        packed_api_key = _packed_value(0)
+        packed_api_secret = _packed_value(1)
+        packed_passphrase = _packed_value(2)
+        packed_chain_id = _packed_value(3)
+        packed_wallet = _packed_value(4)
+
         while len(entry) < 3:
             entry.append("")
 
-        existing_pk = entry[0]
+        existing_pk = entry[0] if entry else None
         normalized_pk: str | None = None
-        if private_key:
+        candidate_pk = private_key or existing_pk
+        if candidate_pk:
+            candidate_pk = str(candidate_pk)
             normalized_pk = (
-                private_key if private_key.startswith("0x") else f"0x{private_key}"
-            )
-        elif existing_pk:
-            normalized_pk = (
-                existing_pk if existing_pk.startswith("0x") else f"0x{existing_pk}"
+                candidate_pk if candidate_pk.startswith("0x") else f"0x{candidate_pk}"
             )
 
         if not normalized_pk:
             raise RuntimeError("Polymarket需要钱包私钥 (apis['polymarket'][0])")
 
         entry[0] = normalized_pk
-        if funder:
-            entry[2] = funder
-        self.funder = entry[2] or self.funder
+
+        existing_wallet = entry[2] if isinstance(entry[2], str) and entry[2] else None
+        effective_wallet = funder or packed_wallet or existing_wallet or self.funder
+        if effective_wallet:
+            entry[2] = effective_wallet
+            self.funder = effective_wallet
+        else:
+            entry[2] = ""
+
+        derived_chain_id: int | None = None
+        if packed_chain_id is not None:
+            try:
+                derived_chain_id = int(packed_chain_id)
+            except (TypeError, ValueError):
+                derived_chain_id = None
+        if chain_id is None and derived_chain_id is not None:
+            self.chain_id = derived_chain_id
+
+        if packed_api_key and packed_api_secret and packed_passphrase:
+            session.__dict__["_polymarket_api_creds"] = {
+                "api_key": packed_api_key,
+                "api_secret": packed_api_secret,
+                "api_passphrase": packed_passphrase,
+            }
 
         apis[API_NAME] = entry
         session.__dict__["_apis"] = apis
@@ -1356,6 +1403,19 @@ class Polymarket:
         session.__dict__["_polymarket_signature_type"] = self.signature_type
         self.auth = True
 
+    @staticmethod
+    def load_poly_api():
+        from dotenv import load_dotenv
+
+        load_dotenv()
+        pk = os.getenv("PK")
+        api_key = os.getenv("CLOB_API_KEY")
+        api_secret = os.getenv("CLOB_API_SECRET")
+        passphrase = os.getenv("CLOB_API_PASSPHRASE")
+        chain_id = os.getenv("CHAIN_ID") or 137
+        wallet_address = os.getenv("POLY_WALLET_ADDRESS")
+        return [pk, "", (api_key, api_secret, passphrase, chain_id, wallet_address)]
+
 @lru_cache(maxsize=8)
 def _get_web3(rpc_url: str):
     from web3 import Web3

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

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