hyperquant 1.3__tar.gz → 1.44__tar.gz

{hyperquant-1.3 → hyperquant-1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.3
+Version: 1.44
 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
@@ -22,7 +22,7 @@ Requires-Dist: lighter-sdk
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: py-clob-client>=0.28.0
-Requires-Dist: pybotters>=1.9.1
+Requires-Dist: pybotters>=1.10
 Requires-Dist: pyecharts>=2.0.8
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: web3>=7.14.0

{hyperquant-1.3 → hyperquant-1.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.3"
+version = "1.44"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }
@@ -13,7 +13,7 @@ dependencies = [
     "cryptography>=44.0.2",
     "numpy>=1.21.0", # Added numpy as a new dependency
     "duckdb>=1.2.2",
-    "pybotters>=1.9.1",
+    "pybotters>=1.10",
     "lighter-sdk",
     "eth-account>=0.10.0",
     "web3>=7.14.0",

{hyperquant-1.3 → hyperquant-1.44}/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.3 → hyperquant-1.44}/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
@@ -16,7 +18,73 @@ class Position(DataStore):
     _KEYS = ["asset", "outcome"]
 
     def _on_response(self, msg: Item) -> None:
-        self._update(msg)
+        if msg:
+            self._clear()
+            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")
+        price_raw = trade.get("price")
+
+        if not asset_id or not outcome or side not in {"BUY", "SELL"}:
+            return
+
+        try:
+            size = float(size_raw)
+        except (TypeError, ValueError):
+            return
+        try:
+            price = float(price_raw)
+        except (TypeError, ValueError):
+            price = None
+
+        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)
+        cur_avg_price = float(existing.get("avgPrice") or 0.0)
+        cur_cost = cur_size * cur_avg_price
+
+        if side == "BUY":
+            new_size = cur_size + size
+            total_bought = cur_total_bought + size
+            # 未拿到成交价时使用当前均价兜底，避免均价被拉低
+            effective_price = price if price is not None else cur_avg_price
+            new_cost = cur_cost + size * effective_price
+        else:  # SELL
+            new_size = cur_size - size
+            total_bought = cur_total_bought
+            # 卖出按照当前均价释放成本
+            new_cost = cur_cost - min(size, cur_size) * cur_avg_price
+
+        if new_size <= 0:
+            new_size = 0.0
+            avg_price = 0.0
+            new_cost = 0.0
+        else:
+            avg_price = max(new_cost, 0.0) / new_size
+
+        rec: dict[str, Any] = {
+            "asset": asset_id,
+            "outcome": outcome,
+            "side": side,
+            "size": new_size,
+            "totalBought": total_bought,
+            "avgPrice": avg_price,
+        }
+
+        if existing:
+            self._update([rec])
+        else:
+            self._insert([rec])
 
 
 class Fill(DataStore):
@@ -123,7 +191,7 @@ class Order(DataStore):
             self._insert([norm])
 
 
-class Trade(DataStore):
+class MyTrade(DataStore):
     """User trades keyed by trade id."""
 
     _KEYS = ["id"]
@@ -154,6 +222,26 @@ class Trade(DataStore):
         else:
             self._insert([normalized])
 
+class Trade(DataStore):
+    """User trades keyed by trade id."""
+
+    _KEYS = ["hash"]
+    _MAXLEN = 500
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        payload = msg or {}
+        if payload:
+            if payload.get("event_type") == "last_trade_price":
+                transaction_hash = payload.get("transaction_hash")
+                if transaction_hash:
+                    payload.update({"hash": transaction_hash})
+                    payload.pop("transaction_hash", None)
+            else:
+                if payload.get("transactionHash"):
+                    payload.update({"hash": payload.get("transactionHash")})
+                    payload.pop("transactionHash", None)
+
+            self._insert([payload])
 
 class Book(DataStore):
     """Full depth order book keyed by Polymarket token id."""
@@ -197,19 +285,36 @@ class Book(DataStore):
             normalized.append(record)
         return normalized
 
+    def _purge_missing_levels(
+        self, *, symbol: str, side: str, new_levels: list[dict[str, Any]]
+    ) -> None:
+        """Remove levels no longer present in the latest snapshot."""
+        existing = self.find({"s": symbol, "S": side})
+        if not existing:
+            return
+        new_prices = {lvl["p"] for lvl in new_levels}
+        stale = [
+            {"s": symbol, "S": side, "p": level["p"]}
+            for level in existing
+            if level.get("p") not in new_prices
+        ]
+        if stale:
+            self._delete(stale)
+
     def _on_message(self, msg: dict[str, Any]) -> None:
         msg_type = msg.get("event_type")
         if msg_type not in {"book", "price_change"}:
             return
 
-        asset_id = msg.get("asset_id") or msg.get("token_id")
-        symbol, alias = self._alias(asset_id)
-        if symbol is None:
-            return
-
         if msg_type == "book":
+            asset_id = msg.get("asset_id") or msg.get("token_id")
+            symbol, alias = self._alias(asset_id)
+            if symbol is None:
+                return
             bids = self._normalize_levels(msg.get("bids"), side="b", symbol=symbol, alias=alias)
             asks = self._normalize_levels(msg.get("asks"), side="a", symbol=symbol, alias=alias)
+            self._purge_missing_levels(symbol=symbol, side="b", new_levels=bids)
+            self._purge_missing_levels(symbol=symbol, side="a", new_levels=asks)
             if bids:
                 self._insert(bids)
             if asks:
@@ -220,6 +325,10 @@ class Book(DataStore):
         updates: list[dict[str, Any]] = []
         removals: list[dict[str, Any]] = []
         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 change.get("side") == "BUY" else "a"
             try:
                 price = float(change["price"])
@@ -252,6 +361,193 @@ 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 Price(DataStore):
+    _KEYS = ["s"]
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        payload = msg.get('payload') or {}
+        data = payload.get('data') or {}
+        symbol = payload.get('symbol')
+
+        if not symbol:
+            return
+        
+        _next = self.get({'s': symbol}) or {}
+        _next_price = _next.get('p')
+        last_price = None
+        
+        if data and isinstance(data, list):
+            last_price = data[-1].get('value')
+        if 'value' in payload:
+            last_price = payload.get('value')
+        
+        if last_price is None:
+            return
+
+        record = {'s': symbol, 'p': last_price}
+        key = {'s': symbol}
+        if self.get(key):
+            self._update([record])
+        else:
+            self._insert([record])
+
+
+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."""
@@ -260,7 +556,7 @@ class Detail(DataStore):
 
     @staticmethod
     def _normalize_entry(market: dict[str, Any], token: dict[str, Any]) -> dict[str, Any]:
-        slug = market.get("market_slug") or market.get("question") or market.get("id")
+        slug = market.get("slug")
         outcome = token.get("outcome")
         alias = slug if outcome is None else f"{slug}:{outcome}"
 
@@ -332,10 +628,14 @@ class Detail(DataStore):
 
             for token in tokens:
                 normalized = self._normalize_entry(market, token)
+                slug: str = market.get("slug")
+                # 取最后一个'-'之前部分
+                base_slug = slug.rsplit("-", 1)[0] if slug else slug
                 # Add or update additional fields from market
                 normalized.update({
                     "condition_id": market.get("conditionId"),
                     "slug": market.get("slug"),
+                    "base_slug": base_slug,
                     "end_date": market.get("endDate"),
                     "start_date": market.get("startDate"),
                     "icon": market.get("icon"),
@@ -362,11 +662,14 @@ 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)
-        self._create("trade", datastore_class=Trade)
+        self._create("mytrade", datastore_class=MyTrade)
         self._create("fill", datastore_class=Fill)
+        self._create("trade", datastore_class=Trade)
+        self._create("price", datastore_class=Price)
 
     @property
     def book(self) -> Book:
@@ -497,7 +800,7 @@ class PolymarketDataStore(DataStoreCollection):
         return self._get("order")
 
     @property
-    def trade(self) -> Trade:
+    def mytrade(self) -> MyTrade:
         """User trade stream keyed by trade id.
 
         Columns include Polymarket websocket ``trade`` payloads, e.g.
@@ -517,6 +820,13 @@ class PolymarketDataStore(DataStoreCollection):
         """
 
         return self._get("trade")
+    
+    @property
+    def price(self) -> Price:
+        """Price DataStore
+        _key: s 
+        """
+        return self._get("price")
 
     @property
     def fill(self) -> Fill:
@@ -541,11 +851,55 @@ 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": "12819879685513143002408869746992985182419696851931617234615358342350852997413",
+                "bio": "",
+                "conditionId": "0xea609d2c6bc2cb20e328be7c89f258b84b35bbe119b44e0a2cfc5f15e6642b3b",
+                "eventSlug": "btc-updown-15m-1763865000",
+                "icon": "https://polymarket-upload.s3.us-east-2.amazonaws.com/BTC+fullsize.png",
+                "name": "infusion",
+                "outcome": "Up",
+                "outcomeIndex": 0,
+                "price": 0.7,
+                "profileImage": "",
+                "proxyWallet": "0x2C060830B6F6B43174b1Cf8B4475db07703c1543",
+                "pseudonym": "Frizzy-Graduate",
+                "side": "BUY",
+                "size": 5,
+                "slug": "btc-updown-15m-1763865000",
+                "timestamp": 1763865085,
+                "title": "Bitcoin Up or Down - November 22, 9:30PM-9:45PM ET",
+                "hash": "0xddea11d695e811686f83379d9269accf1be581fbcb542809c6c67a3cc3002488"
+            }
+        """
+        return self._get("trade")
+    
 
     def onmessage(self, msg: Any, ws: ClientWebSocketResponse | None = None) -> None:
         # 判定msg是否为list
         lst_msg = msg if isinstance(msg, list) else [msg]
         for m in lst_msg:
+            if m == '':
+                continue
+            topic = m.get("topic") or ""
+            if topic in {'crypto_prices_chainlink', 'crypto_prices'}:
+                self.price._on_message(m)
+                continue
             raw_type = m.get("event_type") or m.get("type")
             if not raw_type:
                 continue
@@ -553,7 +907,38 @@ class PolymarketDataStore(DataStoreCollection):
             if msg_type in {"book", "price_change"}:
                 self.book._on_message(m)
             elif msg_type == "order":
-                self.order._on_message(m)
+                self.orders._on_message(m)
             elif msg_type == "trade":
-                self.trade._on_message(m)
+                self.mytrade._on_message(m)
                 self.fill._on_trade(m)
+                self.position.on_trade(m)
+            elif msg_type == 'orders_matched':
+                payload = m.get("payload") or {}
+                if not payload:
+                    continue
+                trade_msg = dict(payload)
+                if "asset_id" not in trade_msg and "asset" in trade_msg:
+                    trade_msg["asset_id"] = trade_msg["asset"]
+                self.trade._on_message(trade_msg)
+    
+    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)
+
+    def onmessage_for_last_trade(self, msg, ws = 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 == "last_trade_price":
+                self.trade._on_message(m)