hyperquant 0.82__tar.gz → 0.84__tar.gz

{hyperquant-0.82 → hyperquant-0.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.82
+Version: 0.84
 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-0.82 → hyperquant-0.84}/apis.json

@@ -14,5 +14,9 @@
     "bg_03e0445d9282f248d22842cfe6f30192",
     "67ec894753d75fec12332881278420863a960ec39c8f5acf1de88aa1da926854",
     "huainian0408"
+  ],
+  "coinw":[
+    "eedb6bc3-fc05-45b3-9bbc-53d2fd1b3a04",
+    "RGMYGU2XHXZNKRKGR6TFU1BZRKXYMOQKZUYY"
   ]
 }

{hyperquant-0.82 → hyperquant-0.84}/pyproject.toml

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

{hyperquant-0.82 → hyperquant-0.84}/src/hyperquant/broker/auth.py

@@ -198,6 +198,75 @@ class Auth:
 
         return args
 
+    @staticmethod
+    def coinw(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        headers: CIMultiDict = kwargs["headers"]
+
+        session = kwargs["session"]
+        try:
+            api_key, secret, _ = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name]
+        except (KeyError, ValueError):
+            raise RuntimeError("CoinW credentials (api_key, secret) are required")
+
+        timestamp = str(int(time.time() * 1000))
+        method_upper = method.upper()
+
+        params = kwargs.get("params")
+        query_string = ""
+        if isinstance(params, dict) and params:
+            query_items = [
+                f"{key}={value}"
+                for key, value in params.items()
+                if value is not None
+            ]
+            query_string = "&".join(query_items)
+        elif url.query_string:
+            query_string = url.query_string
+
+        body_str = ""
+
+        if method_upper == "GET":
+            body = None
+            data = None
+        else:
+            body = kwargs.get("json")
+            data = kwargs.get("data")
+            payload = body if body is not None else data
+            if isinstance(payload, (dict, list)):
+                body_str = pyjson.dumps(payload, separators=(",", ":"), ensure_ascii=False)
+                kwargs["data"] = body_str
+                kwargs.pop("json", None)
+            elif payload is not None:
+                body_str = str(payload)
+                kwargs["data"] = body_str
+                kwargs.pop("json", None)
+
+        if query_string:
+            path = f"{url.raw_path}?{query_string}"
+        else:
+            path = url.raw_path
+
+        message = f"{timestamp}{method_upper}{path}{body_str}"
+        signature = hmac.new(
+            secret, message.encode("utf-8"), hashlib.sha256
+        ).digest()
+        signature_b64 = base64.b64encode(signature).decode("ascii")
+
+        headers.update(
+            {
+                "sign": signature_b64,
+                "api_key": api_key,
+                "timestamp": timestamp,
+            }
+        )
+
+        if method_upper in {"POST", "PUT", "PATCH", "DELETE"} and "data" in kwargs:
+            headers.setdefault("Content-Type", "application/json")
+
+        return args
+
 pybotters.auth.Hosts.items["futures.ourbit.com"] = pybotters.auth.Item(
     "ourbit", Auth.ourbit
 )
@@ -220,4 +289,8 @@ pybotters.auth.Hosts.items["quote.edgex.exchange"] = pybotters.auth.Item(
 
 pybotters.auth.Hosts.items["uuapi.rerrkvifj.com"] = pybotters.auth.Item(
     "lbank", Auth.lbank
-)
+)
+
+pybotters.auth.Hosts.items["api.coinw.com"] = pybotters.auth.Item(
+    "coinw", Auth.coinw
+)

hyperquant-0.84/src/hyperquant/broker/coinw.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Literal, Sequence
+
+import pybotters
+
+from .models.coinw import CoinwFuturesDataStore
+
+logger = logging.getLogger(__name__)
+
+
+class Coinw:
+    """CoinW 永续合约客户端（REST + WebSocket）。"""
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        rest_api: str | None = None,
+        ws_url: str | None = None,
+        web_api: str | None = None,
+    ) -> None:
+        self.client = client
+        self.store = CoinwFuturesDataStore()
+
+        self.rest_api = rest_api or "https://api.coinw.com"
+        self.ws_url_public = ws_url or "wss://ws.futurescw.com/perpum"
+        self.ws_url_private = self.ws_url_public
+        self.web_api = web_api or "https://futuresapi.coinw.com"
+
+        self._ws_private: pybotters.ws.WebSocketApp | None = None
+        self._ws_private_ready = asyncio.Event()
+        self._ws_headers = {
+            "Origin": "https://www.coinw.com",
+            "Referer": "https://www.coinw.com/",
+            "User-Agent": (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+            ),
+        }
+
+    async def __aenter__(self) -> "Coinw":
+        await self.update("detail")
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # pragma: no cover - symmetry
+        return None
+
+    async def update(
+        self,
+        update_type: Literal[
+            "detail",
+            "ticker",
+            "orders",
+            "position",
+            "balance",
+            "all",
+        ] = "all",
+        *,
+        instrument: str | None = None,
+        position_type: Literal["execute", "plan", "planTrigger"] = "execute",
+        page: int | None = None,
+        page_size: int | None = None,
+        open_ids: str | None = None,
+    ) -> None:
+        """刷新本地缓存，使用 CoinW REST API。
+
+        - detail: ``GET /v1/perpum/instruments`` （公共）
+        - ticker: ``GET /v1/perpumPublic/tickers`` （公共）
+        - orders: ``GET /v1/perpum/orders/open`` （私有，需要 ``instrument``）
+        - position: ``GET /v1/perpum/positions`` （私有，需要 ``instrument``）
+        - balance: ``GET /v1/perpum/account/getUserAssets`` （私有）
+        """
+
+        requests: list[Any] = []
+
+        include_detail = update_type in {"detail", "all"}
+        include_ticker = update_type in {"ticker", "all"}
+        include_orders = update_type in {"orders", "all"}
+        include_position = update_type in {"position", "all"}
+        include_balance = update_type in {"balance", "all"}
+
+        if include_detail:
+            requests.append(self.client.get(f"{self.rest_api}/v1/perpum/instruments"))
+
+        if include_ticker:
+            requests.append(self.client.get(f"{self.rest_api}/v1/perpumPublic/tickers"))
+
+        if include_orders:
+            if not instrument:
+                raise ValueError("instrument is required when updating orders")
+            params: dict[str, Any] = {
+                "instrument": instrument,
+                "positionType": position_type,
+            }
+            if page is not None:
+                params["page"] = page
+            if page_size is not None:
+                params["pageSize"] = page_size
+            requests.append(
+                self.client.get(
+                    f"{self.rest_api}/v1/perpum/orders/open",
+                    params=params,
+                )
+            )
+
+        if include_position:
+            if not instrument:
+                raise ValueError("instrument is required when updating positions")
+            params = {"instrument": instrument}
+            if open_ids:
+                params["openIds"] = open_ids
+            requests.append(
+                self.client.get(
+                    f"{self.rest_api}/v1/perpum/positions",
+                    params=params,
+                )
+            )
+
+        if include_balance:
+            requests.append(
+                self.client.get(f"{self.rest_api}/v1/perpum/account/getUserAssets")
+            )
+
+        if not requests:
+            raise ValueError(f"update_type err: {update_type}")
+
+        await self.store.initialize(*requests)
+
+    async def place_order(
+        self,
+        instrument: str,
+        *,
+        direction: Literal["long", "short"],
+        leverage: int,
+        quantity: float | str,
+        quantity_unit: Literal[0, 1, 2, "quote", "contract", "base"] = 0,
+        position_model: Literal[0, 1, "isolated", "cross"] = 0,
+        position_type: Literal["execute", "plan", "planTrigger"] = "execute",
+        price: float | None = None,
+        trigger_price: float | None = None,
+        trigger_type: Literal[0, 1] | None = None,
+        stop_loss_price: float | None = None,
+        stop_profit_price: float | None = None,
+        third_order_id: str | None = None,
+        use_almighty_gold: bool | None = None,
+        gold_id: int | None = None,
+    ) -> dict[str, Any]:
+        """``POST /v1/perpum/order`` 下单。"""
+
+        payload: dict[str, Any] = {
+            "instrument": instrument,
+            "direction": self._normalize_direction(direction),
+            "leverage": int(leverage),
+            "quantityUnit": self._normalize_quantity_unit(quantity_unit),
+            "quantity": self._format_quantity(quantity),
+            "positionModel": self._normalize_position_model(position_model),
+            "positionType": position_type,
+        }
+
+        if price is not None:
+            payload["openPrice"] = price
+        if trigger_price is not None:
+            payload["triggerPrice"] = trigger_price
+        if trigger_type is not None:
+            payload["triggerType"] = int(trigger_type)
+        if stop_loss_price is not None:
+            payload["stopLossPrice"] = stop_loss_price
+        if stop_profit_price is not None:
+            payload["stopProfitPrice"] = stop_profit_price
+        if third_order_id:
+            payload["thirdOrderId"] = third_order_id
+        if use_almighty_gold is not None:
+            payload["useAlmightyGold"] = int(bool(use_almighty_gold))
+        if gold_id is not None:
+            payload["goldId"] = int(gold_id)
+
+        res = await self.client.post(
+            f"{self.rest_api}/v1/perpum/order",
+            data=payload,
+        )
+
+        data = await res.json()
+        return self._ensure_ok("place_order", data)
+
+    async def place_order_web(
+        self,
+        instrument: str,
+        *,
+        direction: Literal["long", "short"],
+        leverage: int | str,
+        quantity_unit: Literal[0, 1, 2],
+        quantity: str | float | int,
+        position_model: Literal[0, 1] = 1,
+        position_type: Literal["plan", "planTrigger", "execute"] = 'plan',
+        open_price: str | float | None = None,
+        contract_type: int = 1,
+        data_type: str = "trade_take",
+        device_id: str,
+        token: str,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """使用 Web 前端接口下单，绕过部分 API 频控策略。
+
+        注意此接口需要传入真实浏览器参数，如 ``device_id`` 与 ``token``。
+        """
+
+        if not device_id or not token:
+            raise ValueError("device_id and token are required for place_order_web")
+
+        url = f"{self.web_api}/v1/futuresc/thirdClient/trade/{instrument}/open"
+
+        payload: dict[str, Any] = {
+            "instrument": instrument,
+            "direction": direction,
+            "leverage": str(leverage),
+            "quantityUnit": quantity_unit,
+            "quantity": str(quantity),
+            "positionModel": position_model,
+            "positionType": position_type,
+            "contractType": contract_type,
+            "dataType": data_type,
+        }
+        if open_price is not None:
+            payload["openPrice"] = str(open_price)
+
+        base_headers = {
+            "accept": "application/json, text/plain, */*",
+            "accept-language": "zh_CN",
+            "appversion": "100.100.100",
+            "cache-control": "no-cache",
+            "clienttag": "web",
+            "content-type": "application/json",
+            "cwdeviceid": device_id,
+            "deviceid": device_id,
+            "devicename": "Chrome V141.0.0.0 (macOS)",
+            "language": "zh_CN",
+            "logintoken": token,
+            "origin": "https://www.coinw.com",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "referer": "https://www.coinw.com/",
+            "sec-ch-ua": '"Microsoft Edge";v="141", "Not?A_Brand";v="8", "Chromium";v="141"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"macOS"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "selecttype": "USD",
+            "systemversion": "macOS 10.15.7",
+            "thirdappid": "coinw",
+            "thirdapptoken": token,
+            "token": token,
+            "user-agent": (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 "
+                "Safari/537.36 Edg/141.0.0.0"
+            ),
+            "withcredentials": "true",
+            "x-authorization": token,
+            "x-language": "zh_CN",
+            "x-locale": "zh_CN",
+            "x-requested-with": "XMLHttpRequest",
+        }
+        if headers:
+            base_headers.update(headers)
+
+        res = await self.client.post(
+            url,
+            json=payload,
+            headers=base_headers,
+            auth=None,
+        )
+        return await res.json()
+
+    async def cancel_order(self, order_id: str | int) -> dict[str, Any]:
+        """``DELETE /v1/perpum/order`` 取消单个订单。"""
+
+        res = await self.client.delete(
+            f"{self.rest_api}/v1/perpum/order",
+            data={"id": str(order_id)},
+        )
+        data = await res.json()
+        return self._ensure_ok("cancel_order", data)
+
+    async def sub_personal(self) -> None:
+        """订阅订单、持仓、资产私有频道。"""
+
+        ws_app = await self._ensure_private_ws()
+        payloads = [
+            {"event": "sub", "params": {"biz": "futures", "type": "order"}},
+            {"event": "sub", "params": {"biz": "futures", "type": "position"}},
+            {"event": "sub", "params": {"biz": "futures", "type": "position_change"}},
+            {"event": "sub", "params": {"biz": "futures", "type": "assets"}},
+        ]
+        for payload in payloads:
+            if ws_app.current_ws.closed:
+                raise ConnectionError("CoinW private websocket closed before subscription.")
+            await ws_app.current_ws.send_json(payload)
+            await asyncio.sleep(0.05)
+
+    async def sub_orderbook(
+        self,
+        pair_codes: Sequence[str] | str,
+        *,
+        depth_limit: int | None = None,
+        biz: str = "futures",
+    ) -> pybotters.ws.WebSocketApp:
+        """订阅 ``type=depth`` 订单簿数据，批量控制发送频率。"""
+
+        if isinstance(pair_codes, str):
+            pair_codes = [pair_codes]
+
+        pair_list = [code for code in pair_codes if code]
+        if not pair_list:
+            raise ValueError("pair_codes must not be empty")
+
+        self.store.book.limit = depth_limit
+
+        subscriptions = [
+            {"event": "sub", "params": {"biz": biz, "type": "depth", "pairCode": code}}
+            for code in pair_list
+        ]
+
+        ws_app = self.client.ws_connect(
+            self.ws_url_public,
+            hdlr_json=self.store.onmessage,
+            headers=self._ws_headers,
+        )
+        await ws_app._event.wait()
+
+        chunk_size = 10
+        for idx in range(0, len(subscriptions), chunk_size):
+            batch = subscriptions[idx : idx + chunk_size]
+            for msg in batch:
+                await ws_app.current_ws.send_json(msg)
+            if idx + chunk_size < len(subscriptions):
+                await asyncio.sleep(2.05)
+
+        return ws_app
+
+    async def _ensure_private_ws(self) -> pybotters.ws.WebSocketApp:
+
+        ws_app = self.client.ws_connect(
+            self.ws_url_private,
+            hdlr_json=self.store.onmessage,
+            headers=self._ws_headers,
+        )
+        await ws_app._event.wait()
+        await ws_app.current_ws._wait_authtask()
+
+        return ws_app
+
+    @staticmethod
+    def _normalize_direction(direction: str) -> str:
+        allowed = {"long", "short"}
+        value = str(direction).lower()
+        if value not in allowed:
+            raise ValueError(f"Unsupported direction: {direction}")
+        return value
+
+    @staticmethod
+    def _normalize_quantity_unit(
+        unit: Literal[0, 1, 2, "quote", "contract", "base"],
+    ) -> int:
+        mapping = {
+            0: 0,
+            1: 1,
+            2: 2,
+            "quote": 0,
+            "contract": 1,
+            "base": 2,
+        }
+        try:
+            return mapping[unit]  # type: ignore[index]
+        except KeyError as exc:  # pragma: no cover - guard
+            raise ValueError(f"Unsupported quantity_unit: {unit}") from exc
+
+    @staticmethod
+    def _normalize_position_model(
+        model: Literal[0, 1, "isolated", "cross"],
+    ) -> int:
+        mapping = {
+            0: 0,
+            1: 1,
+            "isolated": 0,
+            "cross": 1,
+        }
+        try:
+            return mapping[model]  # type: ignore[index]
+        except KeyError as exc:  # pragma: no cover - guard
+            raise ValueError(f"Unsupported position_model: {model}") from exc
+
+    @staticmethod
+    def _format_quantity(quantity: float | str) -> str:
+        if isinstance(quantity, str):
+            return quantity
+        return str(quantity)
+
+    @staticmethod
+    def _ensure_ok(operation: str, data: Any) -> dict[str, Any]:
+        """CoinW REST 成功时返回 ``{'code': 0, ...}``。"""
+
+        if not isinstance(data, dict) or data.get("code") != 0:
+            raise RuntimeError(f"{operation} failed: {data}")
+        payload = data.get("data")
+        if isinstance(payload, dict):
+            return payload
+        return {"data": payload}