hyperquant 1.54__tar.gz → 1.55__tar.gz

{hyperquant-1.54 → hyperquant-1.55}/PKG-INFO

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

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

{hyperquant-1.54 → hyperquant-1.55}/src/hyperquant/broker/polymarket.py

@@ -7,7 +7,8 @@ from datetime import UTC, datetime, timedelta
 from functools import lru_cache
 import os
 import time
-from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
+from typing import Any, Awaitable, Callable, Iterable, Iterator, Literal, Mapping, Sequence
+from urllib.parse import urlsplit, urlunsplit
 
 import json
 
@@ -259,6 +260,8 @@ class Polymarket:
         self._ws_personal: pybotters.ws.WebSocketApp | None = None
         self.auth = False
         self._tick_size_cache: dict[str, tuple[str, float]] = {}
+        self._forward_orders_cfg: dict[str, Any] | None = None
+        self._forward_ws: dict[str, Any] | None = None
 
         self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
 
@@ -276,6 +279,7 @@ class Polymarket:
                 await self._ws_public.current_ws.close()
             self._ws_public = None
             self._ws_public_ready.clear()
+        await self._close_forward_ws()
 
     async def prewarm_connections(
         self,
@@ -296,6 +300,109 @@ class Polymarket:
             except Exception:
                 continue
 
+    async def mount_forward_orders(
+        self,
+        *,
+        mode: Literal["rest", "ws"],
+        url: str,
+        region: str = "afr",
+        session: str = "orders",
+        ws_timeout: float = 30.0,
+        batch_mode: Literal["step", "batch"] = "step",
+        concurrency: int = 5,
+        callback: Callable[[dict[str, Any]], Awaitable[None] | None] | None = None,
+    ) -> None:
+        """Mount forward execution for place_orders/cancel_orders."""
+        cfg = {
+            "mode": mode,
+            "url": url,
+            "region": region,
+            "session": session,
+            "ws_timeout": float(ws_timeout),
+            "batch_mode": batch_mode,
+            "concurrency": int(concurrency),
+            "callback": callback,
+        }
+        if mode == "rest":
+            cfg["url"] = self._normalize_forward_batch_url(url)
+            await self._close_forward_ws()
+        else:
+            cfg["url"] = self._normalize_forward_ws_url(url)
+            await self._ensure_forward_ws_connected(cfg)
+        self._forward_orders_cfg = cfg
+
+    async def unmount_forward_orders(self) -> None:
+        """Disable forward execution and fallback to direct CLOB calls."""
+        await self._close_forward_ws()
+        self._forward_orders_cfg = None
+
+    async def _close_forward_ws(self) -> None:
+        state = self._forward_ws
+        self._forward_ws = None
+        if not state:
+            return
+        task: asyncio.Task | None = state.get("listener")
+        ws: aiohttp.ClientWebSocketResponse | None = state.get("ws")
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if ws and not ws.closed:
+            with suppress(Exception):
+                await ws.close()
+
+    async def _forward_ws_listener(self, ws: aiohttp.ClientWebSocketResponse, cfg: Mapping[str, Any]) -> None:
+        callback = cfg.get("callback")
+        while True:
+            msg = await ws.receive()
+            if msg.type == aiohttp.WSMsgType.TEXT:
+                try:
+                    data = json.loads(msg.data)
+                except Exception:
+                    continue
+                if callback:
+                    try:
+                        ret = callback(data)
+                        if asyncio.iscoroutine(ret):
+                            await ret
+                    except Exception as exc:
+                        self.logger.warning("forward ws callback error: %s", exc)
+                continue
+            if msg.type in {aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSED}:
+                break
+            if msg.type == aiohttp.WSMsgType.ERROR:
+                break
+
+    async def _ensure_forward_ws_connected(self, cfg: Mapping[str, Any] | None = None) -> None:
+        current = cfg or self._forward_orders_cfg
+        if not current or current.get("mode") != "ws":
+            return
+        state = self._forward_ws
+        if state:
+            ws: aiohttp.ClientWebSocketResponse | None = state.get("ws")
+            task: asyncio.Task | None = state.get("listener")
+            if ws and not ws.closed and task and not task.done():
+                return
+            await self._close_forward_ws()
+
+        session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+
+        ws_url = current["url"]
+        sep = "&" if ("?" in ws_url) else "?"
+        ws_url = f"{ws_url}{sep}region={current.get('region', 'afr')}&session={current.get('session', 'orders')}"
+        ws = await session.ws_connect(ws_url, heartbeat=30)
+        # Consume hello once to align message stream.
+        with suppress(Exception):
+            await asyncio.wait_for(ws.receive(), timeout=float(current.get("ws_timeout", 30.0)))
+        listener = asyncio.create_task(self._forward_ws_listener(ws, current))
+        self._forward_ws = {"ws": ws, "listener": listener}
+
     # ------------------------------------------------------------------
     # Store helpers
 
@@ -1358,6 +1465,101 @@ class Polymarket:
             except Exception:
                 return await resp.text()
 
+    def _normalize_forward_batch_url(self, forward_url: str) -> str:
+        parts = urlsplit(forward_url)
+        if not parts.scheme or not parts.netloc:
+            raise ValueError("forward_url must be a valid absolute URL")
+        path = (parts.path or "").rstrip("/")
+        if path.endswith("/forward-batch") or path.endswith("/forward-batch-step"):
+            target_path = path
+        elif path.endswith("/forward"):
+            target_path = f"{path[:-len('/forward')]}/forward-batch-step"
+        else:
+            target_path = f"{path}/forward-batch-step" if path else "/forward-batch-step"
+        return urlunsplit((parts.scheme, parts.netloc, target_path, parts.query, parts.fragment))
+
+    def _normalize_forward_ws_url(self, forward_url: str) -> str:
+        parts = urlsplit(forward_url)
+        if parts.scheme not in {"ws", "wss"} or not parts.netloc:
+            raise ValueError("forward ws url must be a valid ws:// or wss:// URL")
+        path = (parts.path or "").rstrip("/")
+        if not path.endswith("/ws-forward"):
+            path = f"{path}/ws-forward" if path else "/ws-forward"
+        return urlunsplit((parts.scheme, parts.netloc, path, parts.query, parts.fragment))
+
+    def _build_l2_signed_headers(
+        self,
+        *,
+        signer_addr: str,
+        api_key: str,
+        api_secret: str,
+        api_passphrase: str,
+        method: str,
+        path: str,
+        payload: Any,
+    ) -> dict[str, str]:
+        import base64
+        import hashlib
+        import hmac
+
+        ts = int(time.time())
+        serialized = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
+        msg = f"{ts}{method.upper()}{path}{serialized}"
+        secret_bytes = base64.urlsafe_b64decode(api_secret)
+        sig = hmac.new(secret_bytes, msg.encode("utf-8"), hashlib.sha256).digest()
+        sign_b64 = base64.urlsafe_b64encode(sig).decode("utf-8")
+        return {
+            "POLY_ADDRESS": signer_addr,
+            "POLY_SIGNATURE": sign_b64,
+            "POLY_TIMESTAMP": str(ts),
+            "POLY_API_KEY": api_key,
+            "POLY_PASSPHRASE": api_passphrase,
+            "Content-Type": "application/json",
+        }
+
+    async def _submit_forward_requests(self, requests_payload: Sequence[Mapping[str, Any]]) -> Any:
+        cfg = self._forward_orders_cfg
+        if not cfg:
+            raise RuntimeError("forward is not mounted")
+        session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+
+        if cfg["mode"] == "rest":
+            endpoint = cfg["url"]
+            async with session.post(endpoint, json={"requests": list(requests_payload)}) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    raise RuntimeError(f"Forward batch failed: {resp.status} {text}")
+                try:
+                    return await resp.json()
+                except Exception:
+                    return await resp.text()
+
+        await self._ensure_forward_ws_connected(cfg)
+        state = self._forward_ws
+        ws: aiohttp.ClientWebSocketResponse | None = state.get("ws") if state else None
+        if ws is None or ws.closed:
+            raise RuntimeError("forward ws not connected")
+
+        req_id = f"hq-{int(time.time() * 1000)}"
+        msg_type = "batch" if cfg.get("batch_mode") == "batch" else "batch-step"
+        payload: dict[str, Any] = {
+            "type": msg_type,
+            "id": req_id,
+            "requests": list(requests_payload),
+        }
+        if msg_type == "batch":
+            payload["concurrency"] = int(cfg.get("concurrency", 5))
+        await ws.send_json(payload)
+        return {
+            "mode": "ws",
+            "queued": True,
+            "request_id": req_id,
+            "batch_mode": msg_type,
+            "count": len(requests_payload),
+        }
+
     async def post_orders(
         self,
         orders: Iterable[tuple[Mapping[str, Any], str]],
@@ -1447,6 +1649,41 @@ class Polymarket:
                 }
             )
 
+        if self._forward_orders_cfg:
+            session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+            if session is None:
+                raise RuntimeError("pybotters client session missing")
+            creds = getattr(session, "_polymarket_api_creds", None)
+            if not creds:
+                raise RuntimeError("Polymarket API creds missing; call create_or_derive_api_creds")
+            api_key = creds.get("api_key")
+            api_secret = creds.get("api_secret")
+            api_passphrase = creds.get("api_passphrase")
+            if not (api_key and api_secret and api_passphrase):
+                raise RuntimeError("Polymarket API creds incomplete")
+
+            target_url = f"{self.rest_api.rstrip('/')}/order"
+            requests_payload: list[dict[str, Any]] = []
+            for payload in result_body:
+                headers = self._build_l2_signed_headers(
+                    signer_addr=signer_addr,
+                    api_key=api_key,
+                    api_secret=api_secret,
+                    api_passphrase=api_passphrase,
+                    method="POST",
+                    path="/order",
+                    payload=payload,
+                )
+                requests_payload.append(
+                    {
+                        "method": "POST",
+                        "url": target_url,
+                        "headers": headers,
+                        "body": payload,
+                    }
+                )
+            return await self._submit_forward_requests(requests_payload)
+
         return await self._signed_request_via_session("POST", "/orders", result_body)
 
     async def cancel(self, order_id: str) -> Any:
@@ -1455,11 +1692,48 @@ class Polymarket:
         """
         return await self._signed_request_via_session("DELETE", "/order", {"orderID": order_id})
 
-    async def cancel_orders(self, order_ids: Sequence[str]) -> Any:
+    async def cancel_orders(
+        self,
+        order_ids: Sequence[str],
+    ) -> Any:
         """
         {'not_canceled': {}, 'canceled': ['0xb3507e9fda9541c3e038afcb4f24b96efcfa667d46cf5e9e52c41620711818df', '0x4b9c3ee4dee8653f15f716653e8ac83f0a086a38597e6ec4b72be2389c79b8b4']}
         """
-        return await self._signed_request_via_session("DELETE", "/orders", list(order_ids))
+        payload = list(order_ids)
+        if self._forward_orders_cfg:
+            session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+            if session is None:
+                raise RuntimeError("pybotters client session missing")
+            creds = getattr(session, "_polymarket_api_creds", None)
+            if not creds:
+                raise RuntimeError("Polymarket API creds missing; call create_or_derive_api_creds")
+            api_key = creds.get("api_key")
+            api_secret = creds.get("api_secret")
+            api_passphrase = creds.get("api_passphrase")
+            if not (api_key and api_secret and api_passphrase):
+                raise RuntimeError("Polymarket API creds incomplete")
+
+            _, _, signer_addr = self._get_signing_context()
+            headers = self._build_l2_signed_headers(
+                signer_addr=signer_addr,
+                api_key=api_key,
+                api_secret=api_secret,
+                api_passphrase=api_passphrase,
+                method="DELETE",
+                path="/orders",
+                payload=payload,
+            )
+            requests_payload = [
+                {
+                    "method": "DELETE",
+                    "url": f"{self.rest_api.rstrip('/')}/orders",
+                    "headers": headers,
+                    "body": payload,
+                }
+            ]
+            return await self._submit_forward_requests(requests_payload)
+
+        return await self._signed_request_via_session("DELETE", "/orders", payload)
 
     async def cancel_all(self) -> Any:
         """

{hyperquant-1.54 → hyperquant-1.55}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.53"
+version = "1.54"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },