hyperquant 0.81__py3-none-any.whl → 0.83__py3-none-any.whl

hyperquant/broker/auth.py

@@ -192,13 +192,81 @@ class Auth:
                 "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0"
             }
         )
-        print(headers)
 
         # 更新 kwargs.body，保证发出去的与签名一致
         # kwargs.update({"data": raw_body_for_sign})
 
         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
 )
@@ -221,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/broker/coinw.py

@@ -0,0 +1,405 @@
+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",
+            "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`` （公共）
+        - 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_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_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}

hyperquant/broker/lbank.py

@@ -567,7 +567,6 @@ class Lbank:
             headers=self._rest_headers,
         )
         data = await res.json()
-        print(data)
         return self._ensure_ok("query_all", data)
         
 

hyperquant/broker/models/coinw.py

@@ -0,0 +1,612 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Awaitable
+
+import aiohttp
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+class Book(DataStore):
+    """CoinW 合约订单簿数据存储。
+
+    WebSocket 频道: futures/depth
+
+    消息示例（来源: https://www.coinw.com/api-doc/futures-trading/market/subscribe-order-book）
+
+    .. code:: json
+
+        {
+            "biz": "futures",
+            "pairCode": "BTC",
+            "type": "depth",
+            "data": {
+                "asks": [{"p": "95640.3", "m": "0.807"}, ...],
+                "bids": [{"p": "95640.2", "m": "0.068"}, ...]
+            }
+        }
+    """
+
+    _KEYS = ["s", "S", "p", "q"]
+
+    def _init(self) -> None:
+        self.limit: int | None = None
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("data")
+        if not isinstance(data, dict):
+            return
+
+        asks = data.get("asks") or []
+        bids = data.get("bids") or []
+        if not asks and not bids:
+            return
+
+        symbol = (
+            msg.get("pairCode")
+            or data.get("pairCode")
+            or msg.get("symbol")
+            or data.get("symbol")
+        )
+        if not symbol:
+            return
+
+        if self.limit is not None:
+            asks = asks[: self.limit]
+            bids = bids[: self.limit]
+
+        entries: list[dict[str, Any]] = []
+        for side, levels in (("a", asks), ("b", bids)):
+            for level in levels:
+                price = level.get("p") or level.get("price")
+                size = level.get("m") or level.get("q") or level.get("size")
+                if price is None or size is None:
+                    continue
+                entries.append(
+                    {
+                        "s": str(symbol),
+                        "S": side,
+                        "p": str(price),
+                        "q": str(size),
+                    }
+                )
+
+        if not entries:
+            return
+
+        self._find_and_delete({"s": str(symbol)})
+        self._insert(entries)
+
+    def sorted(
+        self, query: Item | None = None, limit: int | None = None
+    ) -> dict[str, list[Item]]:
+        return self._sorted(
+            item_key="S",
+            item_asc_key="a",
+            item_desc_key="b",
+            sort_key="p",
+            query=query,
+            limit=limit,
+        )
+
+
+class Detail(DataStore):
+    """CoinW 合约信息数据存储。
+
+    文档: https://www.coinw.com/api-doc/futures-trading/market/get-instrument-information
+    """
+
+    _KEYS = ["name"]
+
+    @staticmethod
+    def _transform(entry: dict[str, Any]) -> dict[str, Any] | None:
+        if not entry:
+            return None
+        transformed = dict(entry)
+        base = entry.get("name") or entry.get("base")
+        quote = entry.get("quote")
+        pricePrecision = entry.get("pricePrecision")
+        transformed['tick_size'] = 10 ** (-int(pricePrecision))
+        transformed['step_size'] = entry.get("oneLotSize")
+        if base and quote:
+            transformed.setdefault(
+                "symbol", f"{str(base).upper()}_{str(quote).upper()}"
+            )
+        return transformed
+
+    def _onresponse(self, data: Any) -> None:
+        if data is None:
+            self._clear()
+            return
+
+        entries: list[dict[str, Any]]
+        if isinstance(data, dict):
+            entries = data.get("data") or []
+        else:
+            entries = data
+
+        items: list[dict[str, Any]] = []
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            transformed = self._transform(entry)
+            if transformed:
+                items.append(transformed)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+class Orders(DataStore):
+    """CoinW 当前订单数据存储。"""
+
+    _KEYS = ["id"]
+
+    @staticmethod
+    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
+        order_id = entry.get("id")
+        if order_id is None:
+            return None
+        normalized = dict(entry)
+        normalized["id"] = str(order_id)
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        payload = []
+        if isinstance(data, dict):
+            inner = data.get("data")
+            if isinstance(inner, dict):
+                payload = inner.get("rows") or []
+            elif isinstance(inner, list):
+                payload = inner
+        elif isinstance(data, list):
+            payload = data
+
+        items: list[dict[str, Any]] = []
+        for entry in payload or []:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize(entry)
+            if normalized:
+                items.append(normalized)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("data")
+        if isinstance(data, dict) and data.get("result") is not None:
+            return
+
+        entries: list[dict[str, Any]] = []
+        if isinstance(data, list):
+            entries = data
+        elif isinstance(data, dict):
+            entries = data.get("rows") or data.get("data") or []
+
+        if not entries:
+            return
+
+        to_insert: list[dict[str, Any]] = []
+        to_delete: list[dict[str, Any]] = []
+
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize(entry)
+            if not normalized:
+                continue
+
+            status = str(normalized.get("status") or "").lower()
+            order_status = str(normalized.get("orderStatus") or "").lower()
+            remove = status in {"close", "cancel", "canceled"} or order_status in {
+                "finish",
+                "cancel",
+            }
+
+            # query = {"id": normalized["id"]}
+            to_delete.append(normalized)
+            if not remove:
+                to_insert.append(normalized)
+
+        if to_delete:
+            self._delete(to_delete)
+        if to_insert:
+            self._insert(to_insert)
+
+
+class Position(DataStore):
+    """CoinW 当前持仓数据存储。"""
+
+    _KEYS = ["id"]
+
+    @staticmethod
+    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
+        position_id = entry.get("id")
+        if position_id is None:
+            return None
+        normalized = dict(entry)
+        normalized["id"] = str(position_id)
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        payload = []
+        if isinstance(data, dict):
+            payload = data.get("data") or []
+        elif isinstance(data, list):
+            payload = data
+
+        items: list[dict[str, Any]] = []
+        for entry in payload or []:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize(entry)
+            if normalized:
+                items.append(normalized)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("data")
+        if isinstance(data, dict) and data.get("result") is not None:
+            return
+
+        entries: list[dict[str, Any]] = []
+        if isinstance(data, list):
+            entries = data
+        elif isinstance(data, dict):
+            entries = data.get("rows") or data.get("data") or []
+
+        if not entries:
+            return
+
+        to_insert: list[dict[str, Any]] = []
+        to_delete: list[dict[str, Any]] = []
+
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize(entry)
+            if not normalized:
+                continue
+
+            status = normalized.get("status")
+            normalized_status = str(status).lower() if status is not None else ""
+            remove = normalized_status in {"close", "closed", "1", "2"}
+
+            query = {"id": normalized["id"]}
+            to_delete.append(query)
+            if not remove:
+                to_insert.append(normalized)
+
+        if to_delete:
+            self._delete(to_delete)
+        if to_insert:
+            self._insert(to_insert)
+
+
+class Balance(DataStore):
+    """CoinW 合约账户资产数据存储。"""
+
+    _KEYS = ["currency"]
+
+    @staticmethod
+    def _normalize_rest(entry: dict[str, Any]) -> dict[str, Any]:
+        currency = "USDT"
+        normalized = {
+            "currency": currency,
+            "availableMargin": entry.get("availableMargin"),
+            "availableUsdt": entry.get("availableUsdt"),
+            "almightyGold": entry.get("almightyGold"),
+            "alMargin": entry.get("alMargin"),
+            "alFreeze": entry.get("alFreeze"),
+            "time": entry.get("time"),
+            "userId": entry.get("userId"),
+        }
+        if "available" not in normalized:
+            normalized["available"] = entry.get("availableUsdt")
+        normalized["availableMargin"] = entry.get("availableMargin")
+        normalized["margin"] = entry.get("alMargin")
+        normalized["freeze"] = entry.get("alFreeze")
+        return {k: v for k, v in normalized.items() if v is not None}
+
+    @staticmethod
+    def _normalize_ws(entry: dict[str, Any]) -> dict[str, Any] | None:
+        currency = entry.get("currency")
+        if not currency:
+            return None
+        currency_str = str(currency).upper()
+        normalized = dict(entry)
+        normalized["currency"] = currency_str
+        # 对齐 REST 字段
+        if "availableUsdt" not in normalized and "available" in normalized:
+            normalized["availableUsdt"] = normalized["available"]
+        if "alMargin" not in normalized and "margin" in normalized:
+            normalized["alMargin"] = normalized["margin"]
+        if "alFreeze" not in normalized and "freeze" in normalized:
+            normalized["alFreeze"] = normalized["freeze"]
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        entry = None
+        if isinstance(data, dict):
+            entry = data.get("data")
+        if not isinstance(entry, dict):
+            entry = {}
+
+        self._clear()
+        normalized = self._normalize_rest(entry)
+        self._insert([normalized])
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("data")
+        if isinstance(data, dict) and data.get("result") is not None:
+            return
+
+        entries: list[dict[str, Any]] = []
+        if isinstance(data, list):
+            entries = data
+        elif isinstance(data, dict):
+            entries = data.get("rows") or data.get("data") or []
+
+        if not entries:
+            return
+
+        normalized_items: list[dict[str, Any]] = []
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize_ws(entry)
+            if normalized:
+                normalized_items.append(normalized)
+
+        if not normalized_items:
+            return
+
+        currencies = [{"currency": item["currency"]} for item in normalized_items]
+        self._delete(currencies)
+        self._insert(normalized_items)
+
+
+class CoinwFuturesDataStore(DataStoreCollection):
+    """CoinW 合约交易 DataStoreCollection。
+
+    - REST: https://api.coinw.com/v1/perpum/instruments
+    - WebSocket: wss://ws.futurescw.com/perpum (depth)
+    """
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._create("orders", datastore_class=Orders)
+        self._create("position", datastore_class=Position)
+        self._create("balance", datastore_class=Balance)
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        msg_type = msg.get("type")
+        if msg_type == "depth":
+            self.book._on_message(msg)
+        elif msg_type == "order":
+            self.orders._on_message(msg)
+        elif msg_type == "position":
+            self.position._on_message(msg)
+        elif msg_type == "assets":
+            self.balance._on_message(msg)
+
+    async def initialize(self, *aws: Awaitable[aiohttp.ClientResponse]) -> None:
+        for fut in asyncio.as_completed(aws):
+            res = await fut
+            data = await res.json()
+            if res.url.path == "/v1/perpum/instruments":
+                self.detail._onresponse(data)
+            elif res.url.path == "/v1/perpum/orders/open":
+                self.orders._onresponse(data)
+            elif res.url.path == "/v1/perpum/positions":
+                self.position._onresponse(data)
+            elif res.url.path == "/v1/perpum/account/getUserAssets":
+                self.balance._onresponse(data)
+
+    @property
+    def book(self) -> Book:
+        """订单簿深度数据流。
+
+        数据来源：
+          - WebSocket: ``type == "depth"`` （参考 https://www.coinw.com/api-doc/futures-trading/market/subscribe-order-book）
+
+        数据结构（节选）::
+
+            {
+                "s": "BTC",
+                "S": "a",  # 卖单
+                "p": "95640.3",
+                "q": "0.807"
+            }
+        """
+
+        return self._get("book", Book)
+
+    @property
+    def detail(self) -> Detail:
+        """合约基础信息数据流。
+
+        响应示例（节选）:
+
+        .. code:: json
+
+        {
+            "base": "btc",
+            "closeSpread": 0.0002,
+            "commissionRate": 0.0006,
+            "configBo": {
+                "margins": {
+                    "100": 0.075,
+                    "5": 0.00375,
+                    "50": 0.0375,
+                    "20": 0.015,
+                    "10": 0.0075
+                },
+                "simulatedMargins": {
+                    "5": 0.00375,
+                    "20": 0.015,
+                    "10": 0.0075
+                }
+            },
+            "createdDate": 1548950400000,
+            "defaultLeverage": 20,
+            "defaultStopLossRate": 0.99,
+            "defaultStopProfitRate": 100,
+            "depthPrecision": "0.1,1,10,50,100",
+            "iconUrl": "https://hkto-prod.oss-accelerate.aliyuncs.com/4dfca512e957e14f05da07751a96061cf4bfd5df438504f65287fa0a8c3cadb6.svg",
+            "id": 1,
+            "indexId": 1,
+            "leverage": [
+                5,
+                10,
+                20,
+                50,
+                100,
+                125,
+                200
+            ],
+            "makerFee": "0.0001",
+            "maxLeverage": 200,
+            "maxPosition": 20000,
+            "minLeverage": 1,
+            "minSize": 1,
+            "name": "BTC",
+            "oneLotMargin": 1,
+            "oneLotSize": 0.001,
+            "oneMaxPosition": 15000,
+            "openSpread": 0.0003,
+            "orderLimitMaxRate": 0.05,
+            "orderLimitMinRate": 0.05,
+            "orderMarketLimitAmount": 10,
+            "orderPlanLimitAmount": 30,
+            "partitionIds": "2013,2011",
+            "platform": 0,
+            "pricePrecision": 1,
+            "quote": "usdt",
+            "selected": 0,
+            "settledAt": 1761062400000,
+            "settledPeriod": 8,
+            "settlementRate": 0.0004,
+            "sort": 1,
+            "status": "online",
+            "stopCrossPositionRate": 0.1,
+            "stopSurplusRate": 0.01,
+            "takerFee": "0.0006",
+            "updatedDate": 1752040118000,
+            "symbol": "BTC_USDT",
+            "tick_size": 1.0,
+            "step_size": 0.001
+        }
+        """
+
+        return self._get("detail", Detail)
+
+    @property
+    def orders(self) -> Orders:
+        """当前订单数据流。
+
+        数据来源：
+          - REST: ``GET /v1/perpum/orders/open``
+          - WebSocket: ``type == "order"``
+
+        数据结构（节选）::
+
+            {
+                "currentPiece": "1",
+                "leverage": "50",
+                "originalType": "plan",
+                "processStatus": 0,
+                "contractType": 1,
+                "frozenFee": "0",
+                "openPrice": "175",
+                "orderStatus": "unFinish",
+                "instrument": "SOL",
+                "quantityUnit": 1,
+                "source": "web",
+                "updatedDate": 1761109078404,
+                "positionModel": 1,
+                "posType": "plan",
+                "baseSize": "0.1",
+                "quote": "usdt",
+                "liquidateBy": "manual",
+                "makerFee": "0.0001",
+                "totalPiece": "1",
+                "tradePiece": "0",
+                "orderPrice": "175",
+                "id": "33309055657317395",
+                "direction": "long",
+                "margin": "0.35",
+                "indexPrice": "185.68",
+                "quantity": "1",
+                "takerFee": "0.0006",
+                "userId": "1757458",
+                "cancelPiece": "0",
+                "createdDate": 1761109078404,
+                "positionMargin": "0.35",
+                "base": "sol",
+                "status": "open"
+            }
+        """
+
+        return self._get("orders", Orders)
+
+    @property
+    def position(self) -> Position:
+        """当前持仓数据流。
+
+        数据来源：
+          - REST: ``GET /v1/perpum/positions``
+          - WebSocket: ``type == "position"``
+
+        数据结构（节选）::
+
+            {
+                "id": 2435521222631982507,
+                "instrument": "BTC",
+                "direction": "short",
+                "openPrice": 88230.5,
+                "currentPiece": 1,
+                "profitUnreal": 0.0086,
+                "status": "open"
+            }
+        """
+
+        return self._get("position", Position)
+
+    @property
+    def balance(self) -> Balance:
+        """合约账户资产数据流。
+
+        数据来源：
+          - REST: ``GET /v1/perpum/account/getUserAssets``
+          - WebSocket: ``type == "assets"``
+
+        .. code:: json
+
+            {
+                "currency": "USDT",
+                "availableMargin": 0.0,
+                "availableUsdt": 0,
+                "almightyGold": 0.0,
+                "alMargin": 0,
+                "alFreeze": 0,
+                "time": 1761055905797,
+                "userId": 1757458,
+                "available": 0,
+                "margin": 0,
+                "freeze": 0
+            }
+        """
+
+        return self._get("balance", Balance)

hyperquant/broker/ws.py

@@ -1,13 +1,10 @@
 import asyncio
-import base64
 import time
 from typing import Any
 
 import pybotters
+from aiohttp import WSMsgType
 from pybotters.ws import ClientWebSocketResponse, logger
-from pybotters.auth import Hosts
-import urllib
-import yarl
 
 
 class Heartbeat:
@@ -34,11 +31,18 @@ class Heartbeat:
         while not ws.closed:
             await ws.send_str('ping')
             await asyncio.sleep(6)
+    
+    @staticmethod
+    async def coinw(ws: ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_json({"event": "ping"})
+            await asyncio.sleep(10.0)
 
 pybotters.ws.HeartbeatHosts.items['futures.ourbit.com'] = Heartbeat.ourbit
 pybotters.ws.HeartbeatHosts.items['www.ourbit.com'] = Heartbeat.ourbit_spot
 pybotters.ws.HeartbeatHosts.items['quote.edgex.exchange'] = Heartbeat.edgex
 pybotters.ws.HeartbeatHosts.items['uuws.rerrkvifj.com'] = Heartbeat.lbank
+pybotters.ws.HeartbeatHosts.items['ws.futurescw.com'] = Heartbeat.coinw
 
 class WssAuth:
     @staticmethod
@@ -63,4 +67,49 @@ class WssAuth:
                 else:
                     logger.warning(f"WebSocket login failed: {data}")
     
+    @staticmethod
+    async def coinw(ws: ClientWebSocketResponse):
+        creds = ws._response._session.__dict__["_apis"].get(
+            pybotters.ws.AuthHosts.items[ws._response.url.host].name
+        )
+        if not creds:
+            raise RuntimeError("CoinW credentials are required for websocket login.")
+        if isinstance(creds, dict):
+            raise RuntimeError("CoinW credentials must be a sequence, not a dict.")
+        if len(creds) < 1:
+            raise RuntimeError("CoinW credentials are incomplete.")
+
+        api_key = creds[0]
+        secret = creds[1] if len(creds) > 1 else ""
+
+        await ws.send_json(
+            {
+                "event": "login",
+                "params": {
+                    "api_key": api_key,
+                    "passphrase": secret.decode(),
+                },
+            }
+        )
+
+        async for msg in ws:
+            if msg.type != WSMsgType.TEXT:
+                continue
+            try:
+                data:dict = msg.json()
+            except Exception:  # pragma: no cover - defensive
+                continue
+
+            channel = data.get("channel")
+            event_type = data.get("type")
+            if channel == "login" or event_type == "login":
+                result = data.get("data", {}).get("result")
+                if result is not True:
+                    raise RuntimeError(f"CoinW WebSocket login failed: {data}")
+                break
+            if data.get("event") == "pong":
+                # ignore heartbeat responses while waiting
+                continue
+
 pybotters.ws.AuthHosts.items['futures.ourbit.com'] = pybotters.auth.Item("ourbit", WssAuth.ourbit)
+pybotters.ws.AuthHosts.items['ws.futurescw.com'] = pybotters.auth.Item("coinw", WssAuth.coinw)

{hyperquant-0.81.dist-info → hyperquant-0.83.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.81
+Version: 0.83
 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.81.dist-info → hyperquant-0.83.dist-info}/RECORD

@@ -4,18 +4,20 @@ hyperquant/db.py,sha256=i2TjkCbmH4Uxo7UTDvOYBfy973gLcGexdzuT_YcSeIE,6678
 hyperquant/draw.py,sha256=up_lQ3pHeVLoNOyh9vPjgNwjD0M-6_IetSGviQUgjhY,54624
 hyperquant/logkit.py,sha256=nUo7nx5eONvK39GOhWwS41zNRL756P2J7-5xGzwXnTY,8462
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
-hyperquant/broker/auth.py,sha256=IIWbqgflJzCcd1Se5W6vT6jjPiiLmjYmWGdiNb6JXbM,7696
+hyperquant/broker/auth.py,sha256=xNZEQP0LRRV9BkT2uXBJ-vFfeahUnRVq1bjIT6YbQu8,10089
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
+hyperquant/broker/coinw.py,sha256=iNAQQ562KeIBbADgyAarTMDwCXdA9qO3-LwFBPvxH-U,14023
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
-hyperquant/broker/lbank.py,sha256=npacHfV0VYJCBg8BX2lGa-ngMxY-lQE6cB_a0WL2iwA,22201
+hyperquant/broker/lbank.py,sha256=98M5wmSoeHwbBYMA3rh25zqLb6fQKVaEmwqALF5nOvY,22181
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
-hyperquant/broker/ws.py,sha256=9Zu5JSLj-ylYEVmFmRwvZDDnVYKwb37cLHfZzA0AZGc,2200
+hyperquant/broker/ws.py,sha256=Ozr5gBzVQ7cnxajT0MdpyKNyVgoCUu6LLjErU9fZxgc,4080
 hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQJKcmyk,95785
 hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb84D8,8296
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
 hyperquant/broker/lib/util.py,sha256=iMU1qF0CHj5zzlIMEQGwjz-qtEVosEe7slXOCuB7Rcw,566
 hyperquant/broker/models/bitget.py,sha256=0RwDY75KrJb-c-oYoMxbqxWfsILe-n_Npojz4UFUq7c,11389
+hyperquant/broker/models/coinw.py,sha256=iEBMTiZ_UjjlwhUGA74e6vvR2pXCl1ZoGKSyBPgqTsw,18658
 hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
 hyperquant/broker/models/lbank.py,sha256=vHkNKxIMzpoC_EwcZnEOPOupizF92yGWi9GKxvYYFUQ,19181
@@ -24,6 +26,6 @@ hyperquant/datavison/_util.py,sha256=92qk4vO856RqycO0YqEIHJlEg-W9XKapDVqAMxe6rbw
 hyperquant/datavison/binance.py,sha256=3yNKTqvt_vUQcxzeX4ocMsI5k6Q6gLZrvgXxAEad6Kc,5001
 hyperquant/datavison/coinglass.py,sha256=PEjdjISP9QUKD_xzXNzhJ9WFDTlkBrRQlVL-5pxD5mo,10482
 hyperquant/datavison/okx.py,sha256=yg8WrdQ7wgWHNAInIgsWPM47N3Wkfr253169IPAycAY,6898
-hyperquant-0.81.dist-info/METADATA,sha256=JAd-E7Z2dt0T4CciFdfHuERvoFXMfSWDbIi_9SOlhAk,4317
-hyperquant-0.81.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.81.dist-info/RECORD,,
+hyperquant-0.83.dist-info/METADATA,sha256=SlHTbSAsclL15RMQjveqABInk7gil66sZljrdp0IUlk,4317
+hyperquant-0.83.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.83.dist-info/RECORD,,