hyperquant 1.34__tar.gz → 1.35__tar.gz

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

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

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

{hyperquant-1.34 → hyperquant-1.35}/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.35}/src/hyperquant/broker/models/polymarket.py

@@ -18,6 +18,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 +201,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):
@@ -583,27 +631,35 @@ class PolymarketDataStore(DataStoreCollection):
     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 +680,6 @@ 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)

{hyperquant-1.34 → hyperquant-1.35}/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:
@@ -266,6 +275,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 +308,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 +324,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 +1182,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 +1322,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 +1335,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:
-            normalized_pk = (
-                private_key if private_key.startswith("0x") else f"0x{private_key}"
-            )
-        elif existing_pk:
+        candidate_pk = private_key or existing_pk
+        if candidate_pk:
+            candidate_pk = str(candidate_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 +1402,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.35}/uv.lock

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