hyperquant 1.47__tar.gz → 1.49__tar.gz

{hyperquant-1.47 → hyperquant-1.49}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.47"
+version = "1.49"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }
@@ -17,7 +17,7 @@ dependencies = [
     "eth-account>=0.10.0",
     "web3>=7.14.0",
     "python-dotenv>=1.2.1",
-    "coincurve>=21.0.0",
+    "coincurve>=21.0.0"
 ]
 readme = "README.md"
 requires-python = ">=3.13"

{hyperquant-1.47 → hyperquant-1.49}/src/hyperquant/broker/auth.py

@@ -13,11 +13,18 @@ import json as pyjson
 from urllib.parse import urlencode
 from datetime import datetime, timezone
 from eth_account import Account
-from eth_account.messages import encode_typed_data
+try:
+    from eth_account.messages import encode_typed_data
+except ImportError:
+    from eth_account.messages import encode_structured_data as encode_typed_data
 from eth_utils import keccak, to_checksum_address
 import secrets
 from random import random
 
+try:
+    from coincurve import PrivateKey as _CoincurvePrivateKey
+except Exception:  # pragma: no cover - optional dependency
+    _CoincurvePrivateKey = None
 
 POLY_ADDRESS = "POLY_ADDRESS"
 POLY_SIGNATURE = "POLY_SIGNATURE"
@@ -859,10 +866,8 @@ class Auth:
         Avoids heavy typed-data helpers by caching type/domain hashes and
         signing the final digest directly.
         """
-        try:
-            from coincurve import PrivateKey
-        except Exception as e:  # pragma: no cover - optional dependency
-            raise RuntimeError("coincurve is required for sign_polymarket_order2") from e
+        if _CoincurvePrivateKey is None:
+            raise RuntimeError("coincurve is required for sign_polymarket_order2")
 
         try:
             now_ts = datetime.now().replace(tzinfo=timezone.utc).timestamp()
@@ -901,7 +906,7 @@ class Auth:
         typed_hash = keccak(b"\x19\x01" + domain_sep + msg_hash)
 
         pk_bytes = bytes.fromhex(private_key[2:] if private_key.startswith("0x") else private_key)
-        sig65 = PrivateKey(pk_bytes).sign_recoverable(typed_hash, hasher=None)
+        sig65 = _CoincurvePrivateKey(pk_bytes).sign_recoverable(typed_hash, hasher=None)
         r, s, rec_id = sig65[:32], sig65[32:64], sig65[64]
         v = rec_id + 27  # align with eth_account v
         signature = "0x" + (r + s + bytes([v])).hex()

{hyperquant-1.47 → hyperquant-1.49}/src/hyperquant/broker/models/polymarket.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass, field
 from heapq import heappop, heappush
+import time
 from typing import TYPE_CHECKING, Any, Iterable
 
 from pybotters.store import DataStore, DataStoreCollection
@@ -15,11 +16,37 @@ if TYPE_CHECKING:
 class Position(DataStore):
     """Position DataStore keyed by Polymarket token id."""
 
-    _KEYS = ["asset", "outcome"]
+    _KEYS = ["asset"]
 
-    def _on_response(self, msg: Item) -> None:
+    def _init(self) -> None:
+        # 缓存LIVE订单已计入的size_matched: {order_id: size_matched}
+        self._live_cache: dict[str, float] = {}
+
+
+    def sorted(
+        self, query: Item | None = None, limit: int | None = None
+    ) -> dict[str, list[Item]]:
+        """按ts降序排列，按outcome分组"""
+        if query is None:
+            query = {}
+        result: dict[str, list[Item]] = {}
+        for item in self:
+            if all(k in item and query[k] == item[k] for k in query):
+                outcome = item.get("outcome") or "unknown"
+                if outcome not in result:
+                    result[outcome] = []
+                result[outcome].append(item)
+        for outcome in result:
+            result[outcome].sort(key=lambda x: (x.get("eventSlug") or '0'), reverse=True)
+            if limit:
+                result[outcome] = result[outcome][:limit]
+        return result
+
+    def _on_response(self, msg: list[Item]) -> None:
         if msg:
             self._clear()
+            for rec in msg:
+                rec["ts"] = 0
             self._update(msg)
 
     def on_trade(self, trade: Item) -> None:
@@ -33,6 +60,7 @@ class Position(DataStore):
         size_raw = trade.get("size")
         price_raw = trade.get("price")
 
+
         if not asset_id or not outcome or side not in {"BUY", "SELL"}:
             return
 
@@ -45,6 +73,8 @@ class Position(DataStore):
         except (TypeError, ValueError):
             price = None
 
+
+
         key = {"asset": asset_id, "outcome": outcome}
         existing = self.get(key) or {}
 
@@ -86,6 +116,85 @@ class Position(DataStore):
         else:
             self._insert([rec])
 
+    def _on_order(self, order: dict[str, Any]) -> None:
+        """通过order更新持仓，处理LIVE时部分成交的增量统计"""
+        # print(order)
+        # order写入本地尝试后续分析
+        with open("polymarket_orders.log", "a") as f:
+            f.write(json.dumps(order) + "\n")
+        order_id = order.get("id")
+        asset_id = order.get("asset_id")
+        outcome = order.get("outcome")
+        side = str(order.get("side") or "").upper()
+        size_matched = float(order.get("size_matched") or 0)
+        price = float(order.get("price") or 0)
+        status = str(order.get("status") or "").upper()
+
+        if not order_id or not asset_id or not outcome or side not in {"BUY", "SELL"}:
+            return
+
+        cached = self._live_cache.get(order_id, 0.0)
+
+        if status == "LIVE":
+            # LIVE时计算增量
+            delta = size_matched - cached
+            if delta > 0:
+                self._live_cache[order_id] = size_matched
+                self._apply_trade(asset_id, outcome, side, delta, price)
+        elif status in {"CANCELED", "MATCHED"}:
+            # 订单完结：计算最终增量 = 最终size_matched - 已计入的cached
+            delta = size_matched - cached
+            if delta > 0:
+                self._apply_trade(asset_id, outcome, side, delta, price)
+            # 清理缓存
+            self._live_cache.pop(order_id, None)
+
+    def _apply_trade(self, asset_id: str, outcome: str, side: str, size: float, price: float) -> None:
+        """应用成交到持仓"""
+        if size <= 0:
+            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)
+        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 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,
+            "ts": int(time.time() * 1000),
+        }
+
+        if existing:
+            self._update([rec])
+        else:
+            self._insert([rec])
+
+
 
 class Fill(DataStore):
     """Fill records keyed by maker order id."""
@@ -169,6 +278,7 @@ class Order(DataStore):
         return normalized
 
     def _on_response(self, items: list[dict[str, Any]] | dict[str, Any]) -> None:
+        """增量同步：insert新增、update变更、delete消失的订单"""
         rows: list[dict[str, Any]] = []
         if isinstance(items, dict):
             items = [items]
@@ -176,20 +286,34 @@ class Order(DataStore):
             norm = self._normalize(it)
             if norm:
                 rows.append(norm)
-        self._clear()
-        if rows:
-            self._insert(rows)
+
+        # 构建新订单id集合
+        new_ids = {r["id"] for r in rows}
+
+        # 删除不再存在的订单（传入完整状态）
+        to_delete = [dict(item) for item in self if item["id"] not in new_ids]
+        if to_delete:
+            self._delete(to_delete)
+
+        # 插入或更新
+        for row in rows:
+            existing = self.get({"id": row["id"]})
+            if existing:
+                # 有变化才update
+                if any(existing.get(k) != row.get(k) for k in row):
+                    self._update([row])
+            else:
+                self._insert([row])
 
     def _on_message(self, msg: dict[str, Any]) -> None:
-        norm = self._normalize(msg)
-        if not norm:
-            return
-        key = {"id": norm["id"]}
-        if self.get(key):
-            self._update([norm])
-        else:
-            self._insert([norm])
+        status = str(msg.get("status") or "").upper()
+        # CANCELED MATCHED 删除
+        order = self.get({"id": msg.get("id")})
+        if not order:
+            self._insert([msg])
 
+        if status in {"CANCELED", "MATCHED"}:
+            self._delete([msg])
 
 class MyTrade(DataStore):
     """User trades keyed by trade id."""
@@ -795,6 +919,7 @@ class PolymarketDataStore(DataStoreCollection):
               "order_type": "GTC",
               "created_at": 1762912331
             }
+
         """
 
         return self._get("order")
@@ -908,10 +1033,12 @@ class PolymarketDataStore(DataStoreCollection):
                 self.book._on_message(m)
             elif msg_type == "order":
                 self.orders._on_message(m)
+                self.position._on_order(m)
+
             elif msg_type == "trade":
                 self.mytrade._on_message(m)
-                self.fill._on_trade(m)
-                self.position.on_trade(m)
+                # self.fill._on_trade(m)
+                # self.position.on_trade(m)
             elif msg_type == 'orders_matched':
                 payload = m.get("payload") or {}
                 if not payload:

{hyperquant-1.47 → hyperquant-1.49}/src/hyperquant/broker/polymarket.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from contextlib import suppress
 from datetime import UTC, datetime, timedelta
 from functools import lru_cache
 import os
+import time
 from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
 
 import json
@@ -27,6 +29,7 @@ DEFAULT_BASE_SLUG = "btc-updown-15m"
 HOURLY_BITCOIN_BASE_SLUG = "bitcoin-up-or-down"
 DEFAULT_INTERVAL = 15 * 60
 DEFAULT_WINDOW = 8
+TICK_SIZE_CACHE_TTL_SECS = 300
 API_NAME = "polymarket"
 END_CURSOR = "LTE="
 USDC_CONTRACT = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
@@ -227,6 +230,16 @@ class Polymarket:
         signature_type: int | None = None,
         funder: str | None = None
     ) -> None:
+        # Logger (per-class, safe default)
+        self.logger = logging.getLogger(f"{API_NAME}.{self.__class__.__name__}")
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(
+                "[%(asctime)s][%(levelname)s][%(name)s] %(message)s"
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+            self.logger.setLevel(logging.INFO)
         self.client = client
         self.rest_api = (rest_api or DEFAULT_REST_ENDPOINT).rstrip("/")
         self.ws_public = ws_public or DEFAULT_WS_ENDPOINT
@@ -242,6 +255,7 @@ class Polymarket:
         self._ws_public_ready = asyncio.Event()
         self._ws_personal: pybotters.ws.WebSocketApp | None = None
         self.auth = False
+        self._tick_size_cache: dict[str, tuple[str, float]] = {}
 
         self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
 
@@ -260,6 +274,25 @@ class Polymarket:
             self._ws_public = None
             self._ws_public_ready.clear()
 
+    async def prewarm_connections(
+        self,
+        endpoints: Sequence[str] | None = None,
+        timeout: float = 1.0,
+    ) -> None:
+        """Pre-warm HTTP connections to reduce first-request latency."""
+        if endpoints is None:
+            endpoints = ("/ok", "/time")
+        session = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+        for endpoint in endpoints:
+            url = f"{self.rest_api}{endpoint}"
+            try:
+                async with session.get(url, timeout=timeout) as resp:
+                    await resp.read()
+            except Exception:
+                continue
+
     # ------------------------------------------------------------------
     # Store helpers
 
@@ -271,22 +304,29 @@ class Polymarket:
             "book",
             "books",
             "position",
-            "history_position",
             "orders",
-        ] = "all",
+        ] | Sequence[str] = "all",
         *,
         token_ids: Sequence[str] | str | None = None,
         limit: int | None = None,
-        funder: str | None = None,
-        event_id: str | None = None
     ) -> None:
-        """Refresh cached data using Polymarket REST endpoints."""
+        """Refresh cached data using Polymarket REST endpoints.
+        
+        update_type 可以是单个字符串或列表，例如:
+            update_type='position'
+            update_type=['position', 'orders']
+        """
+        # 统一转为 set
+        if isinstance(update_type, str):
+            types = {update_type}
+        else:
+            types = set(update_type)
 
-        include_detail = update_type in {"all", "detail", "markets"}
-        include_books = update_type in {"all", "book", "books"}
-        include_position = update_type in {"all", "position"}
-        include_history_position = update_type in {"all", "history_position"}
-        include_orders = update_type in {"all", "orders"}
+        include_detail = "all" in types or "detail" in types or "markets" in types
+        include_books = "all" in types or "book" in types or "books" in types
+        include_position = "all" in types or "position" in types
+        include_history_position = "history_position" in types
+        include_orders = "all" in types or "orders" in types
 
         if include_books and token_ids is None:
             raise ValueError("token_ids are required when updating books")
@@ -315,21 +355,11 @@ class Polymarket:
             )
         
         if include_position or include_history_position:
-            funder = funder or self.funder
-            path = '/positions' if include_position else '/closed-positions'
-            params = {"user": funder, 'sizeThreshold': 0.1}
-            if event_id:
-                params.update({'eventId': event_id})
             tasks.append(
                 (
                     "position",
                     asyncio.create_task(
-                        self._rest(
-                            "GET",
-                            path,
-                            params=params,
-                            host=DEFAULT_DATA_ENDPOINT
-                        )
+                        self.get_mergeable_positions()
                     ),
                 )
             )
@@ -342,8 +372,25 @@ class Polymarket:
             raise ValueError(f"Unsupported update_type={update_type}")
 
         results: dict[str, Any] = {}
-        for key, fut in tasks:
-            results[key] = await fut
+
+        keys = [k for k, _ in tasks]
+        futs = [f for _, f in tasks]
+
+        done = await asyncio.gather(*futs, return_exceptions=True)
+
+        for key, res in zip(keys, done):
+            if isinstance(res, Exception):
+                # REST 更新为 best-effort：记录错误但不中断整体流程
+                try:
+                    logger = getattr(self, "logger", None)
+                    if logger:
+                        logger.warning(f"[update] {key} failed: {res}", exc_info=True)
+                    else:
+                        print(f"[update] {key} failed: {res}")
+                except Exception:
+                    pass
+                continue
+            results[key] = res
 
 
         if "books" in results:
@@ -441,12 +488,12 @@ class Polymarket:
 
         wsapp = self.client.ws_connect(
             RTS_DATA_ENDPOINT,
+            send_json=payload,
             hdlr_str=callback,
             heartbeat=5,
         )
 
         await wsapp._event.wait()
-        await wsapp.current_ws.send_json(payload)
         return wsapp
 
 
@@ -480,6 +527,9 @@ class Polymarket:
         self,
         callback: Any = None,
         markets: Sequence[str] | None = None,
+        rest_sync: bool = True,
+        rest_order_sync_interval: int = 5,
+        rest_position_sync_interval: int = 8,
     ) -> pybotters.ws.WebSocketApp:
         """Subscribe to personal updates (requires authentication)."""
 
@@ -487,8 +537,15 @@ class Polymarket:
         if not creds:
             raise RuntimeError("Polymarket API credentials are required for personal subscriptions")
 
+        # 记录 position store 最后更新时间
+        last_position_update = time.time()
+        
         def _handler(message, ws=None):
+            nonlocal last_position_update
             self.store.onmessage(message, ws)
+            # 检测是否是 position 相关消息
+            if isinstance(message, dict) and message.get('event_type') in ('order', 'trade'):
+                last_position_update = time.time()
             if callback:
                 callback(message, ws)
 
@@ -503,14 +560,45 @@ class Polymarket:
         auth = {"apiKey": api_key, "secret": api_secret, "passphrase": api_passphrase}
         payload = {"markets": list(markets or []), "type": "user", "auth": auth}
 
+        # 在开始前用rest_api同步持仓
+        await self.update('position')
+
+        # 后台任务：3秒无更新则同步持仓
+        async def _rest_sync_watchdog():
+            nonlocal last_position_update
+            last_orders_update = time.time()
+            while True:
+                await asyncio.sleep(1)
+                now = time.time()
+                # position: 6秒无更新则同步
+                if now - last_position_update > rest_position_sync_interval:
+                    try:
+                        await self.update('position')
+                        last_position_update = now
+                    except Exception:
+                        pass
+                # orders: 每3秒同步一次
+                if now - last_orders_update > rest_order_sync_interval:
+                    try:
+                        await self.update('orders')
+                        last_orders_update = now
+                    except Exception:
+                        pass
+        
+        if rest_sync:
+            asyncio.create_task(_rest_sync_watchdog())
+
+        # 使用 send_json 参数，这样重连后会自动重新订阅
         self._ws_personal = self.client.ws_connect(
             "wss://ws-subscriptions-clob.polymarket.com/ws/user",
+            send_json=payload,
             hdlr_json=effective_cb,
             heartbeat=30,
             auth=None,
         )
         await self._ws_personal._event.wait()
-        await self._ws_personal.current_ws.send_json(payload)
+
+
         return self._ws_personal
     
     async def sub_trades(self, slug: str):
@@ -522,7 +610,6 @@ class Polymarket:
                     "topic": "activity",
                     "type": "orders_matched",
                     "filters":  json.dumps({"event_slug": slug}, separators=(',', ':'))
-                    # "filters": "{\"event_slug\":\"btc-updown-15m-1762951500\"}"
                 }
             ]
         }
@@ -537,14 +624,14 @@ class Polymarket:
             
             self.store.onmessage(data, ws)
 
-        
+        # 使用 send_json 参数，重连后自动重新订阅
         wsapp = self.client.ws_connect(
             RTS_DATA_ENDPOINT,
+            send_json=payload,
             hdlr_str=callback,
             heartbeat=5
         )
         await wsapp._event.wait()
-        await wsapp.current_ws.send_json(payload)
         return wsapp
     
 
@@ -945,9 +1032,12 @@ class Polymarket:
         request_path = path
         url = f"{self.rest_api}{request_path}"
         payload_obj = dict(body) if isinstance(body, dict) else body
-        serialized = (
-            str(payload_obj).replace("'", '"') if payload_obj is not None else ""
-        )
+        if payload_obj is None:
+            serialized = ""
+        elif isinstance(payload_obj, str):
+            serialized = payload_obj
+        else:
+            serialized = json.dumps(payload_obj, separators=(",", ":"), ensure_ascii=False)
         secret_bytes = base64.urlsafe_b64decode(api_secret)
         msg = f"{ts}{method}{request_path}{serialized}"
         sig = hmac.new(secret_bytes, msg.encode("utf-8"), hashlib.sha256).digest()
@@ -1181,18 +1271,24 @@ class Polymarket:
     async def _resolve_tick_size(self, token_id: str, tick_size: str | float | None) -> str:
         if tick_size is not None:
             return str(tick_size)
+        cached = self._tick_size_cache.get(token_id)
+        now = time.time()
+        if cached and (now - cached[1]) < TICK_SIZE_CACHE_TTL_SECS:
+            return cached[0]
         tick_resp = await self.get_tick_size(token_id)
         if isinstance(tick_resp, dict):
-            return str(tick_resp.get("minimum_tick_size") or tick_resp.get("tick_size") or "0.01")
-        return str(tick_resp)
+            resolved = str(
+                tick_resp.get("minimum_tick_size") or tick_resp.get("tick_size") or "0.01"
+            )
+        else:
+            resolved = str(tick_resp)
+        self._tick_size_cache[token_id] = (resolved, now)
+        return resolved
 
     async def _resolve_fee_rate(self, token_id: str, fee_rate_bps: int | None) -> int:
         if fee_rate_bps is not None:
             return int(fee_rate_bps)
-        fee_resp = await self.get_fee_rate(token_id)
-        if isinstance(fee_resp, dict):
-            return int(fee_resp.get("base_fee", 0))
-        return int(fee_resp or 0)
+        return 0
         
 
     async def _signed_request_via_session(
@@ -1231,9 +1327,12 @@ class Polymarket:
             payload_obj = dict(body)
         else:
             payload_obj = body
-        serialized = (
-            str(payload_obj).replace("'", '"') if payload_obj is not None else ""
-        )
+        if payload_obj is None:
+            serialized = ""
+        elif isinstance(payload_obj, str):
+            serialized = payload_obj
+        else:
+            serialized = json.dumps(payload_obj, separators=(",", ":"), ensure_ascii=False)
         msg = f"{ts}{method}{request_path}{serialized}"
         sig = hmac.new(secret_bytes, msg.encode("utf-8"), hashlib.sha256).digest()
         sign_b64 = base64.urlsafe_b64encode(sig).decode("utf-8")
@@ -1433,6 +1532,33 @@ class Polymarket:
             position = position / 1e6
         return position
 
+    async def get_mergeable_positions(
+        self,
+        *,
+        size_threshold: float = 0.1,
+        limit: int = 100,
+        sort_by: str = "TOKENS",
+        sort_direction: str = "DESC",
+        user: str | None = None,
+        neg_risk: bool = False,
+        mergeable: bool = True,
+    ) -> Any:
+        params = {
+            "sizeThreshold": str(size_threshold),
+            "limit": str(limit),
+            "sortBy": sort_by,
+            "sortDirection": sort_direction,
+            "mergeable": str(mergeable).lower(),
+        }
+        if user is not None:
+            params["user"] = user
+        else:
+            params['user'] = self.funder
+            
+        if neg_risk:
+            params["negRisk"] = "true"
+        return await self._rest("GET", "/positions", params=params, host=DEFAULT_DATA_ENDPOINT)
+
 
     async def merge_tokens_strict(
         self,