hyperquant 0.88__py3-none-any.whl → 0.91__py3-none-any.whl

hyperquant/broker/coinup.py

@@ -0,0 +1,590 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import datetime, timezone
+import hashlib
+import json
+from typing import Any, Literal, Sequence
+
+import pybotters
+import rnet
+
+from .models.coinup import CoinUpDataStore
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_SECURITY_INFO = (
+    '{"log_BSDeviceFingerprint":"0","log_original":"0","log_CHFIT_DEVICEID":"0"}'
+)
+_SECRET_PREFIX = "HJ@%*AZ_J"
+_DEFAULT_UA = (
+    "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"
+)
+
+
+class Coinup:
+    """CoinUp 永续合约客户端（REST via rnet + WebSocket depth）。
+
+    与 CoinW 客户端结构保持一致，差异点：
+
+    - REST 请求使用 :mod:`rnet`，以规避指纹检测。
+    - 仅订单簿 ``book`` 频道依赖 WebSocket，其他数据通过 REST 刷新。
+    """
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        rest_client: rnet.Client | None = None,
+        rest_api_common: str | None = None,
+        rest_api_futures: str | None = None,
+        ws_url: str | None = None,
+        security_info: str | None = None,
+        exchange_token: str | None = None,
+        emulation: rnet.Emulation | rnet.EmulationOption | None = None,
+        rest_headers_common: dict[str, str] | None = None,
+        rest_headers_futures: dict[str, str] | None = None,
+    ) -> None:
+        self.client = client
+        self.store = CoinUpDataStore()
+
+        self.rest_api_common = rest_api_common or "https://www.coinup.io/fe-co-api"
+        self.rest_api_futures = rest_api_futures or "https://futures.coinup.io/fe-co-api"
+        self.ws_url = ws_url or "wss://futuresws.marketketac.com/kline-api/ws"
+
+        self.security_info = security_info or _DEFAULT_SECURITY_INFO
+        self._emulation = emulation or rnet.Emulation.Safari26
+
+        self._rest_client = rest_client or rnet.Client(
+            emulation=self._emulation,
+            headers={"User-Agent": _DEFAULT_UA},
+            allow_redirects=False,
+            history=False,
+        )
+        self._owns_rest_client = rest_client is None
+
+        common_headers = {
+            "Content-Type": "application/json",
+            "Origin": "https://www.coinup.io",
+            "Referer": "https://www.coinup.io/",
+            "User-Agent": _DEFAULT_UA,
+        }
+        futures_headers = {
+            "Content-Type": "application/json",
+            "Origin": "https://futures.coinup.io",
+            "Referer": "https://futures.coinup.io/zh_CN/trade",
+            "User-Agent": _DEFAULT_UA,
+            "exchange-client": "pc",
+            "exchange-language": "zh_CN",
+        }
+        if rest_headers_common:
+            common_headers.update(rest_headers_common)
+        if rest_headers_futures:
+            futures_headers.update(rest_headers_futures)
+
+        self._exchange_token = exchange_token or self._extract_exchange_token()
+        if self._exchange_token:
+            futures_headers["exchange-token"] = self._exchange_token
+
+        self._headers_common = common_headers
+        self._headers_futures = futures_headers
+
+    async def __aenter__(self) -> "Coinup":
+        await self.update("detail")
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # pragma: no cover - symmetry
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """Close the underlying rnet client if we created it."""
+
+        if self._owns_rest_client and hasattr(self._rest_client, "close"):
+            await self._rest_client.close()
+    
+    def get_contract_id(self, symbol: str) -> str | None:
+        """根据交易对获取合约 ID。"""
+
+        detail = self.store.detail.get({"symbol": symbol})
+        if detail is None:
+            return None
+        contract_id = detail.get("id")
+        if contract_id is None:
+            return None
+        return str(contract_id)
+
+    async def update(
+        self,
+        update_type: Literal[
+            "detail",
+            "position",
+            "balance",
+            "orders",
+            "history_order",
+            "history_orders",
+            "all",
+        ] = "all",
+        *,
+        detail_payload: dict[str, Any] | None = None,
+        assets_payload: dict[str, Any] | None = None,
+        assets_endpoint: Literal["get_assets_list", "wallet_and_unrealized"] = "get_assets_list",
+        orders_payload: dict[str, Any] | None = None,
+        history_orders_payload: dict[str, Any] | None = None,
+    ) -> None:
+        """刷新本地缓存，所有 REST 请求通过 rnet 发送。
+
+        - detail: ``POST /common/public_info`` （公共接口）
+        - position/balance: ``POST /position/get_assets_list`` （返回仓位 & 余额）
+          - 备选 ``/position/wallet_and_unrealized`` 可通过 ``assets_endpoint`` 指定
+        - orders: ``POST /order/current_order_list`` （私有）
+        - history_order: ``POST /order/history_order_list`` （私有）
+        """
+
+        include_detail = update_type in {"detail", "all"}
+        include_position = update_type in {"position", "all"}
+        include_balance = update_type in {"balance", "all"}
+        include_orders = update_type in {"orders", "all"}
+        include_history_orders = update_type in {
+            "history_order",
+            "history_orders",
+            "all",
+        }
+
+        include_assets = include_position or include_balance
+
+        if not (include_detail or include_assets or include_orders or include_history_orders):
+            raise ValueError(f"Unsupported update_type: {update_type}")
+
+        tasks: dict[str, asyncio.Task[Any]] = {}
+
+        if include_detail:
+            tasks["detail"] = asyncio.create_task(
+                self._fetch_detail(detail_payload)
+            )
+
+        if include_assets:
+            tasks["assets"] = asyncio.create_task(
+                self._fetch_assets(assets_payload, endpoint=assets_endpoint)
+            )
+
+        if include_orders:
+            tasks["orders"] = asyncio.create_task(self._fetch_orders(orders_payload))
+
+        if include_history_orders:
+            tasks["history_orders"] = asyncio.create_task(
+                self._fetch_history_orders(history_orders_payload)
+            )
+
+        results: dict[str, Any] = {}
+        try:
+            for key, task in tasks.items():
+                results[key] = await task
+        except Exception:
+            for task in tasks.values():
+                task.cancel()
+            raise
+
+        if include_detail and "detail" in results:
+            self.store.detail._onresponse(results["detail"])
+
+        assets_data = results.get("assets")
+        if assets_data is not None:
+            if include_position:
+                self.store.position._onresponse(assets_data)
+            if include_balance:
+                self.store.balance._onresponse(assets_data)
+
+        if include_orders:
+            orders_data = results.get("orders")
+            if orders_data is not None:
+                self.store.orders._onresponse(orders_data)
+
+        if include_history_orders:
+            history_data = results.get("history_orders")
+            if history_data is not None:
+                self.store.history_orders._onresponse(history_data)
+
+    async def sub_orderbook(
+        self,
+        channels: Sequence[str] | str,
+        *,
+        depth_step: str = "step0",
+        depth_limit: int | None = None,
+    ) -> pybotters.ws.WebSocketApp:
+        """订阅订单簿深度频道。
+
+        参数 ``channels`` 支持 ``subSymbol`` 或完整频道名称：
+
+        - ``"e_wlfiusdt"`` -> 发送 ``market_e_wlfiusdt_depth_step0``
+        - ``"market_e_wlfiusdt_depth_step0"`` -> 原样发送
+        """
+
+        if isinstance(channels, str):
+            channels = [channels]
+
+        payloads = []
+        for channel in channels:
+            ch = channel.lower()
+            if not ch.startswith("market_"):
+                ch = f"market_{ch}_depth_{depth_step}"
+            payloads.append(
+                {
+                    "event": "sub",
+                    "params": {
+                        "channel": ch,
+                        "cb_id": ch.split("_depth_", 1)[0].replace("market_", ""),
+                    },
+                }
+            )
+
+        if not payloads:
+            raise ValueError("channels must not be empty")
+
+        self.store.book.limit = depth_limit
+
+        ws_headers = {
+            "Origin": "https://futures.coinup.io",
+            "Referer": "https://futures.coinup.io/zh_CN/trade",
+            "User-Agent": _DEFAULT_UA,
+        }
+
+        ws_app = self.client.ws_connect(
+            self.ws_url,
+            hdlr_bytes=self.store.onmessage,
+            headers=ws_headers,
+            autoping=False,
+        )
+        await ws_app._event.wait()
+
+        for payload in payloads:
+            await ws_app.current_ws.send_json(payload)
+            await asyncio.sleep(0.05)
+
+        return ws_app
+
+    async def place_order(
+        self,
+        symbol: str,
+        *,
+        side: Literal["buy", "sell", "BUY", "SELL"],
+        volume: float | int | str,
+        order_type: Literal["limit", "market", 1, 2] = "limit",
+        price: float | int | str | None = None,
+        position_type: int | str = 1,
+        leverage_level: int | str = 1,
+        offset: Literal["open", "close", "OPEN", "CLOSE"] = "open",
+        order_unit: int | str = 2,
+        trigger_price: float | int | str | None = None,
+        is_condition_order: bool = False,
+        is_oto: bool = False,
+        is_check_liq: int | bool = 1,
+        secret: str | None = None,
+        take_profit_trigger: float | int | str | None = None,
+        take_profit_price: float | int | str | None = 0,
+        take_profit_type: int | None = 2,
+        stop_loss_trigger: float | int | str | None = None,
+        stop_loss_price: float | int | str | None = 0,
+        stop_loss_type: int | None = 2,
+        extra_params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        ``POST /order/order_create`` 下单（默认支持限价/市价）。
+        当 close 时, volume为张数
+
+        Args:
+            symbol: 交易对符号（如 "BTC_USDT"），将自动解析为 contract_id。
+        """
+        contract_id = self.get_contract_id(symbol)
+        if contract_id is None:
+            raise ValueError(f"Invalid symbol: {symbol}")
+
+        normalized_side = self._normalize_side(side)
+        normalized_offset = self._normalize_offset(offset)
+        order_type_code = self._normalize_order_type(order_type)
+
+        if order_type_code == 1 and price is None:
+            raise ValueError("price is required for CoinUp limit orders")
+        price_value = self._format_price(price)
+        if order_type_code == 1 and price_value is None:
+            raise ValueError("price is required for CoinUp limit orders")
+        if price_value is None:
+            price_value = 0
+
+        volume_str = self._format_volume(volume)
+        trigger_price_value = self._format_price(trigger_price)
+        take_profit_trigger_value = self._format_price(take_profit_trigger)
+        take_profit_price_value = self._format_price(take_profit_price)
+        stop_loss_trigger_value = self._format_price(stop_loss_trigger)
+        stop_loss_price_value = self._format_price(stop_loss_price)
+
+        payload: dict[str, Any] = {
+            "contractId": contract_id,
+            "positionType": int(position_type),
+            "side": normalized_side,
+            "leverageLevel": int(leverage_level),
+            "price": price_value,
+            "volume": volume_str,
+            "triggerPrice": trigger_price_value,
+            "open": normalized_offset,
+            "type": order_type_code,
+            "isConditionOrder": bool(is_condition_order),
+            "isOto": bool(is_oto),
+            "orderUnit": int(order_unit),
+            "isCheckLiq": int(is_check_liq),
+            "takerProfitTrigger": take_profit_trigger_value,
+            "takerProfitPrice": take_profit_price_value,
+            "takerProfitType": take_profit_type,
+            "stopLossTrigger": stop_loss_trigger_value,
+            "stopLossPrice": stop_loss_price_value,
+            "stopLossType": stop_loss_type,
+        }
+        if extra_params:
+            payload.update(extra_params)
+
+        if secret is None:
+            payload["secret"] = self._generate_secret(
+                contract_id=str(contract_id),
+                leverage_level=str(leverage_level),
+                position_type=str(position_type),
+                price=price_value,
+                side=normalized_side,
+                order_type=str(order_type_code),
+                volume=volume_str,
+            )
+        else:
+            payload["secret"] = secret
+
+        body = self._build_payload(payload)
+        data = await self._rest_post(
+            f"{self.rest_api_futures}/order/order_create",
+            body,
+            self._headers_futures,
+        )
+        result = self._ensure_success("place_order", data)
+        return result.get("data") or {}
+
+    async def cancel_order(
+        self,
+        symbol: str,
+        order_id: str | int,
+        *,
+        is_condition_order: bool = False,
+        extra_params: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        ``POST /order/order_cancel`` 取消指定订单。
+
+        Args:
+            symbol: 交易对符号（如 "BTC_USDT"），将自动解析为 contract_id。
+        """
+        contract_id = self.get_contract_id(symbol)
+        if contract_id is None:
+            raise ValueError(f"Invalid symbol: {symbol}")
+
+        payload: dict[str, Any] = {
+            "contractId": contract_id,
+            "orderId": str(order_id),
+            "isConditionOrder": bool(is_condition_order),
+        }
+        if extra_params:
+            payload.update(extra_params)
+
+        body = self._build_payload(payload)
+        data = await self._rest_post(
+            f"{self.rest_api_futures}/order/order_cancel",
+            body,
+            self._headers_futures,
+        )
+
+        result = self._ensure_success("cancel_order", data)
+        return result.get("data")
+
+    def set_exchange_token(self, token: str | None) -> None:
+        """Update the ``exchange-token`` header used for CoinUp private REST calls."""
+
+        self._exchange_token = token
+        if token:
+            self._headers_futures["exchange-token"] = token
+        else:
+            self._headers_futures.pop("exchange-token", None)
+
+    def _build_payload(self, overrides: dict[str, Any] | None = None) -> dict[str, Any]:
+        payload = {
+            "uaTime": datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
+            "securityInfo": self.security_info,
+        }
+        if overrides:
+            payload.update(overrides)
+        return payload
+
+    async def _fetch_detail(self, payload: dict[str, Any] | None) -> Any:
+        url = f"{self.rest_api_common}/common/public_info"
+        data = await self._rest_post(
+            url,
+            self._build_payload(payload),
+            self._headers_common,
+        )
+        return data
+
+    async def _fetch_assets(
+        self,
+        payload: dict[str, Any] | None,
+        *,
+        endpoint: str,
+    ) -> Any:
+        url = f"{self.rest_api_futures}/position/{endpoint}"
+        data = await self._rest_post(
+            url,
+            self._build_payload(payload),
+            self._headers_futures,
+        )
+        return data
+
+    async def _rest_post(
+        self,
+        url: str,
+        payload: dict[str, Any],
+        headers: dict[str, str],
+    ) -> Any:
+        response = await self._rest_client.post(
+            url,
+            json=payload,
+            headers=headers,
+        )
+        try:
+            status = response.status.as_int()
+            if status >= 400:
+                text = await response.text()
+                raise RuntimeError(
+                    f"CoinUp REST request failed ({status}): {text}"
+                )
+            return await response.json()
+        finally:
+            await response.close()
+
+    async def _fetch_orders(self, payload: dict[str, Any] | None) -> Any:
+        url = f"{self.rest_api_futures}/order/current_order_list"
+        data = await self._rest_post(
+            url,
+            self._build_payload(payload or {"contractId": ""}),
+            self._headers_futures,
+        )
+        return data
+
+    async def _fetch_history_orders(self, payload: dict[str, Any] | None) -> Any:
+        url = f"{self.rest_api_futures}/order/history_order_list"
+        data = await self._rest_post(
+            url,
+            self._build_payload(payload or {"contractId": ""}),
+            self._headers_futures,
+        )
+        return data
+
+    def _extract_exchange_token(self) -> str | None:
+        """Best-effort fetch of token from pybotters credential store."""
+
+        session = getattr(self.client, "_session", None)
+        if not session:
+            return None
+        apis = getattr(session, "__dict__", {}).get("_apis")
+        if not isinstance(apis, dict):
+            return None
+        creds = apis.get("coinup")
+        if not creds:
+            return None
+        token = creds[0]
+        return str(token) if token else None
+
+    @staticmethod
+    def _ensure_success(operation: str, payload: Any) -> dict[str, Any]:
+        if not isinstance(payload, dict):
+            raise RuntimeError(f"{operation} failed: unexpected response {payload}")
+        code = payload.get("code")
+        succ = payload.get("succ")
+        if code is not None and str(code) != "0":
+            raise RuntimeError(f"{operation} failed: {payload}")
+        if succ is False:
+            raise RuntimeError(f"{operation} failed: {payload}")
+        return payload
+
+    @staticmethod
+    def _normalize_side(side: str) -> str:
+        value = str(side).upper()
+        if value not in {"BUY", "SELL"}:
+            raise ValueError(f"Unsupported side: {side}")
+        return value
+
+    @staticmethod
+    def _normalize_offset(offset: str) -> str:
+        value = str(offset).upper()
+        mapping = {"OPEN": "OPEN", "CLOSE": "CLOSE"}
+        try:
+            return mapping[value]
+        except KeyError as exc:
+            raise ValueError(f"Unsupported offset: {offset}") from exc
+
+    @staticmethod
+    def _normalize_order_type(order_type: Literal["limit", "market", 1, 2]) -> int:
+        mapping = {
+            "limit": 1,
+            "market": 2,
+            1: 1,
+            2: 2,
+        }
+        try:
+            return mapping[order_type]  # type: ignore[index]
+        except KeyError as exc:
+            raise ValueError(f"Unsupported order_type: {order_type}") from exc
+
+    @staticmethod
+    def _generate_secret(
+        contract_id: str,
+        leverage_level: str,
+        position_type: str,
+        price: float | int | str,
+        side: str,
+        order_type: str,
+        volume: str,
+    ) -> str:
+        data = {
+            "contractId": contract_id,
+            "leverageLevel": leverage_level,
+            "positionType": position_type,
+            "price": Coinup._stringify_number(price),
+            "side": side,
+            "type": order_type,
+            "volume": Coinup._stringify_number(volume),
+        }
+        text = json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+        raw = f"{_SECRET_PREFIX}{text}"
+        return hashlib.md5(raw.encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def _format_price(value: float | int | str | None) -> float | int | str | None:
+        if value is None:
+            return None
+        if isinstance(value, (float, int)):
+            return float(value)
+        return value
+
+    @staticmethod
+    def _format_volume(value: float | int | str) -> str:
+        return str(value)
+
+    @staticmethod
+    def _stringify_number(value: float | int | str | None) -> str:
+        if value is None:
+            return "0"
+        if isinstance(value, str):
+            return value
+        if isinstance(value, int):
+            return str(value)
+        if isinstance(value, float):
+            if value.is_integer():
+                return str(int(value))
+            text = format(value, "f").rstrip("0").rstrip(".")
+            return text or "0"
+        return str(value)

hyperquant/broker/coinw.py

@@ -60,11 +60,10 @@ class Coinw:
             "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,
+        instrument: str | None = None,
     ) -> None:
         """刷新本地缓存，使用 CoinW REST API。
 
@@ -108,16 +107,8 @@ class Coinw:
             )
 
         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,
-                )
+                self.client.get(f"{self.rest_api}/v1/perpum/positions/all")
             )
 
         if include_balance:
@@ -186,6 +177,51 @@ class Coinw:
         data = await res.json()
         return self._ensure_ok("place_order", data)
 
+    async def close_position(
+        self,
+        open_id: str | int,
+        *,
+        position_type: Literal["plan", "planTrigger", "execute"] = "plan",
+        close_num: str | float | int | None = None,
+        close_rate: str | float | int | None = None,
+        order_price: str | float | None = None,
+        instrument: str | None = None,
+    ) -> dict[str, Any]:
+        """关闭单个仓位（``DELETE /v1/perpum/positions``）。
+
+        Params
+        ------
+        open_id: ``openId`` / 持仓唯一 ID。
+        position_type: 订单类型 ``plan`` / ``planTrigger`` / ``execute``。
+        close_num: 按合约数量平仓（与 ``close_rate`` 至少指定其一）。
+        close_rate: 按比例平仓（0-1）。
+        order_price: 限价平仓时指定价格。
+        instrument: 交易品种（部分情况下需要传入，例如限价单）。
+        """
+
+        if close_num is None and close_rate is None:
+            raise ValueError("close_num or close_rate must be provided")
+
+        payload: dict[str, Any] = {
+            "id": str(open_id),
+            "positionType": position_type,
+        }
+        if close_num is not None:
+            payload["closeNum"] = str(close_num)
+        if close_rate is not None:
+            payload["closeRate"] = str(close_rate)
+        if order_price is not None:
+            payload["orderPrice"] = str(order_price)
+        if instrument is not None:
+            payload["instrument"] = instrument
+
+        res = await self.client.delete(
+            f"{self.rest_api}/v1/perpum/positions",
+            data=payload,
+        )
+        data = await res.json()
+        return self._ensure_ok("close_position", data)
+
     async def place_order_web(
         self,
         instrument: str,

hyperquant/broker/models/coinup.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Awaitable, TYPE_CHECKING
+import zlib
+
+from aiohttp import ClientResponse
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+logger = logging.getLogger(__name__)
+
+# {"event_rep":"","channel":"market_e_wlfiusdt_depth_step0","data":null,"tick":{"asks":[[0.1402,9864],[0.1403,23388],[0.1404,9531],[0.1405,4995],[0.1406,3074],[0.1407,18736],[0.1408,3514],[0.1409,6326],[0.141,13217],[0.1411,18253],[0.1412,12214],[0.1413,15243],[0.1414,3606],[0.1415,14894],[0.1416,7932],[0.1417,4973],[0.1418,13031],[0.1419,19793],[0.142,17093],[0.1421,19395],[0.1422,12793],[0.1423,17846],[0.1424,15320],[0.1425,13313],[0.1426,20405],[0.1427,6611],[0.1428,17688],[0.1429,16308],[0.143,10073],[0.1431,15438]],"buys":[[0.1401,9473],[0.14,17486],[0.1399,11957],[0.1398,4824],[0.1397,18447],[0.1396,16929],[0.1395,19859],[0.1394,7283],[0.1393,19609],[0.1392,13638],[0.1391,4146],[0.139,3924],[0.1389,21574],[0.1388,14692],[0.1387,13772],[0.1386,21153],[0.1385,19533],[0.1384,20164],[0.1383,2645],[0.1382,17852],[0.1381,21453],[0.138,19162],[0.1379,17365],[0.1378,9061],[0.1377,14713],[0.1376,12023],[0.1375,11245],[0.1374,9633],[0.1373,5124],[0.1372,5140]]},"ts":1761239630000,"status":"ok"}
+
+class Book(DataStore):
+
+    _KEYS = ["s", "S", "p"]
+
+    def _init(self) -> None:
+        self.limit: int | None = None
+
+    def _on_message(self, msg: Any) -> None:
+        asks = msg["tick"]["asks"]
+        bids = msg["tick"]["buys"]
+        if self.limit is not None:
+            asks = asks[: self.limit]
+            bids = bids[: self.limit]
+        chanel = msg["channel"]
+        symbol = chanel.split("_")[2].upper()
+        asks = [
+            {"s": symbol, "S": "a", "p": float(price), "q": float(quantity)} for price, quantity in asks
+        ]
+        bids = [
+            {"s": symbol, "S": "b", "p": float(price), "q": float(quantity)} for price, quantity in bids
+        ]
+        self._clear()
+        self._insert(asks + bids)
+
+class Detail(DataStore):
+
+    _KEYS = ["symbol"]
+
+    def _onresponse(self, data: Any) -> None:
+        data = data.get("data", {})
+        clist = data.get("contractList", [])
+        # coinResultVo -> marginCoinPrecision 取出来
+        for c in clist:
+            p = c.get("coinResultVo", {}).get("marginCoinPrecision")
+            p = 10 ** (-p)
+            c["tick_size"] = p
+            c['TickSize'] = p  # 兼容用大写开头的字段
+        self._update(clist)
+
+class Position(DataStore):
+
+    _KEYS = ["symbol"]
+
+    def _onresponse(self, data: Any) -> None:
+        data = data.get("data", [])
+        p_list = data.get("positionList", [])
+        self._clear()
+        self._update(p_list)
+
+class Balance(DataStore):
+
+    _KEYS = ["symbol"]
+
+    def _onresponse(self, data: Any) -> None:
+        data = data.get("data", [])
+        b_list = data.get("accountList", [])
+        self._clear()
+        self._update(b_list)
+
+class Orders(DataStore):
+
+    _KEYS = ["orderId"]
+
+    @staticmethod
+    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
+        order_id = entry.get("orderId")
+        if order_id is None:
+            return None
+        normalized = dict(entry)
+        normalized["orderId"] = str(order_id)
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        payload: Any = data
+        if isinstance(data, dict):
+            payload = data.get("data") or data
+            if isinstance(payload, dict):
+                payload = payload.get("orderList") or payload.get("orders") or []
+
+        items: list[dict[str, Any]] = []
+        if isinstance(payload, list):
+            for entry in payload:
+                if not isinstance(entry, dict):
+                    continue
+                normalized = self._normalize(entry)
+                if normalized:
+                    items.append(normalized)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+class HistoryOrders(DataStore):
+
+    _KEYS = ["orderId"]
+
+    @staticmethod
+    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
+        order_id = entry.get("orderId")
+        if order_id is None:
+            return None
+        normalized = dict(entry)
+        normalized["orderId"] = str(order_id)
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        payload: Any = data
+        if isinstance(data, dict):
+            payload = data.get("data") or data
+            if isinstance(payload, dict):
+                payload = payload.get("orderList") or payload.get("orders") or []
+
+        items: list[dict[str, Any]] = []
+        if isinstance(payload, list):
+            for entry in payload:
+                if not isinstance(entry, dict):
+                    continue
+                normalized = self._normalize(entry)
+                if normalized:
+                    items.append(normalized)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+class CoinUpDataStore(DataStoreCollection):
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._create("position", datastore_class=Position)
+        self._create("balance", datastore_class=Balance)
+        self._create("orders", datastore_class=Orders)
+        self._create("history_orders", datastore_class=HistoryOrders)
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        decompressed = zlib.decompress(msg, 16 + zlib.MAX_WBITS)
+        text = decompressed.decode("utf-8")
+        data = json.loads(text)
+        chanel = data.get("channel", "")
+        if 'depth' in chanel:
+            self.book._on_message(data)
+
+    def onresponse(self, data: Any) -> None:
+        pass
+    
+
+    @property
+    def book(self) -> Book:
+        """
+        .. code:: json
+
+            {
+                "s": "BTCUSDT",
+                "S": "a",  # 卖单
+                "p": "95640.3",
+                "q": "0.807"
+            }
+        
+        """
+        return self._get("book")
+
+    @property
+    def detail(self) -> Detail:
+        """
+        .. code:: json
+
+            {
+                "id": 117,
+                "contractName": "E-RESOLV-USDT",
+                "symbol": "RESOLV-USDT",
+                "contractType": "E",
+                "coType": "E",
+                "contractShowType": "USDT合约",
+                "deliveryKind": "0",
+                "contractSide": 1,
+                "multiplier": 22.8000000000000000,
+                "multiplierCoin": "RESOLV",
+                "marginCoin": "USDT",
+                "originalCoin": "USDT",
+                "marginRate": 1.00000000,
+                "capitalStartTime": 0,
+                "capitalFrequency": 8,
+                "settlementFrequency": 1,
+                "brokerId": 1,
+                "base": "RESOLV",
+                "quote": "USDT",
+                "coinResultVo": {
+                    "symbolPricePrecision": 5,
+                    "depth": [
+                        "5",
+                        "4",
+                        "3"
+                    ],
+                    "minOrderVolume": 1,
+                    "minOrderMoney": 1,
+                    "maxMarketVolume": 5000000,
+                    "maxMarketMoney": 6411360,
+                    "maxLimitVolume": 5000000,
+                    "maxLimitMoney": 5000000.0000000000000000,
+                    "priceRange": 0.3000000000,
+                    "marginCoinPrecision": 4,
+                    "fundsInStatus": 1,
+                    "fundsOutStatus": 1
+                },
+                "sort": 100,
+                "maxLever": 75,
+                "minLever": 1,
+                "contractOtherName": "RESOLV/USDT",
+                "subSymbol": "e_resolvusdt",
+                "classification": 1,
+                "nextCapitalSettTime": 1761292800000,
+                "tick_size": 0.0001
+            }
+        """
+        return self._get("detail")
+
+    @property
+    def position(self) -> Position:
+        """
+        _key: symbol
+
+        .. code:: json
+
+            {
+                "id": 256538,
+                "contractId": 169,
+                "contractName": "E-WLFI-USDT",
+                "contractOtherName": "WLFI/USDT",
+                "symbol": "WLFI-USDT",
+                "positionVolume": 1.0,
+                "canCloseVolume": 1.0,
+                "closeVolume": 0.0,
+                "openAvgPrice": 0.1409,
+                "indexPrice": 0.14040034,
+                "reducePrice": -0.9769279224708908,
+                "holdAmount": 16.53718437074,
+                "marginRate": 7.852395215348719,
+                "realizedAmount": 0.0,
+                "returnRate": -0.0177310149041873,
+                "orderSide": "BUY",
+                "positionType": 1,
+                "canUseAmount": 16.11598335074,
+                "canSubMarginAmount": 0,
+                "openRealizedAmount": -0.0074949,
+                "keepRate": 0.015,
+                "maxFeeRate": 2.0E-4,
+                "unRealizedAmount": -0.0074949,
+                "leverageLevel": 5,
+                "positionBalance": 2.1060051,
+                "tradeFee": "-0.0004",
+                "capitalFee": "0",
+                "closeProfit": "0",
+                "settleProfit": "0",
+                "shareAmount": "0",
+                "historyRealizedAmount": "-0.0004227",
+                "profitRealizedAmount": "-0.0004",
+                "openAmount": 0.4227,
+                "adlLevel": 2
+            }
+        
+        """
+        return self._get("position")
+
+    @property
+    def balance(self) -> Balance:
+        """
+        _key: symbol
+
+        .. code:: json
+
+            {
+                "symbol": "USDT",
+                "originalCoin": "USDT",
+                "unRealizedAmount": "-0.0074949",
+                "realizedAmount": "0",
+                "totalMargin": "16.53718437074",
+                "totalAmount": "16.53718437074",
+                "canUseAmount": 16.11598335074,
+                "availableAmount": 16.11598335074,
+                "isolateMargin": "0",
+                "walletBalance": "16.54467927074",
+                "lockAmount": "0",
+                "accountNormal": "16.54467927074",
+                "totalMarginRate": "7.8523952153487187"
+            }
+        """
+        return self._get("balance")
+
+    @property
+    def orders(self) -> Orders:
+        """
+        _key: orderId
+
+        .. code:: json
+
+            {
+                "orderId": "2951913499074783723",
+                "contractId": 169,
+                "side": "SELL",
+                "price": 0.15,
+                "volume": 1,
+                "status": 0
+            }
+        """
+        return self._get("orders")
+
+    @property
+    def history_orders(self) -> HistoryOrders:
+        """
+        _key: orderId
+
+        历史委托记录，与 ``orders`` 结构一致。
+        """
+        return self._get("history_orders")

hyperquant/broker/models/coinw.py

@@ -282,20 +282,6 @@ class Position(DataStore):
 
     _KEYS = ["openId"]
 
-    @staticmethod
-    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
-        open_id = entry.get("openId")
-        if open_id is None:
-            return None
-        normalized = dict(entry)
-        normalized["openId"] = str(open_id)
-        normalized["status"] = str(entry.get("status") or entry.get("orderStatus") or "").lower()
-        normalized["is_closed"] = normalized["status"] in {"close", "closed", "finish"}
-        normalized["currentPiece"] = str(entry.get("currentPiece")) if entry.get("currentPiece") is not None else None
-        normalized["closedPiece"] = str(entry.get("closedPiece")) if entry.get("closedPiece") is not None else None
-        normalized["quantity"] = str(entry.get("quantity")) if entry.get("quantity") is not None else None
-        normalized["updatedDate"] = entry.get("updatedDate")
-        return normalized
 
     def _onresponse(self, data: Any) -> None:
         payload = []
@@ -308,9 +294,8 @@ class Position(DataStore):
         for entry in payload or []:
             if not isinstance(entry, dict):
                 continue
-            normalized = self._normalize(entry)
-            if normalized:
-                items.append(normalized)
+            entry['openId'] = str(entry.get("id"))
+            items.append(entry)
 
         self._clear()
         if items:
@@ -318,6 +303,7 @@ class Position(DataStore):
 
     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
 
@@ -337,17 +323,14 @@ class Position(DataStore):
         for entry in entries:
             if not isinstance(entry, dict):
                 continue
-            normalized = self._normalize(entry)
-            if not normalized:
-                continue
+            normalized = entry
 
-            criteria = {"openId": normalized["openId"]}
 
-            if normalized.get("is_closed"):
-                to_delete.append(criteria)
+            if normalized.get("status") == 'close':
+                to_delete.append(normalized)
                 continue
 
-            if self.find(criteria):
+            if self.find(normalized):
                 to_update.append(normalized)
             else:
                 to_insert.append(normalized)
@@ -460,6 +443,7 @@ class CoinwFuturesDataStore(DataStoreCollection):
 
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
         msg_type = msg.get("type")
+        # print(msg)
         if msg_type == "depth":
             self.book._on_message(msg)
         elif msg_type == "order":
@@ -481,7 +465,7 @@ class CoinwFuturesDataStore(DataStoreCollection):
                 self.ticker._onresponse(data)
             elif res.url.path == "/v1/perpum/orders/open":
                 self.orders._onresponse(data)
-            elif res.url.path == "/v1/perpum/positions":
+            elif res.url.path == "/v1/perpum/positions/all":
                 self.position._onresponse(data)
             elif res.url.path == "/v1/perpum/account/getUserAssets":
                 self.balance._onresponse(data)
@@ -666,17 +650,48 @@ class CoinwFuturesDataStore(DataStoreCollection):
           - REST: ``GET /v1/perpum/positions``
           - WebSocket: ``type == "position"``
 
-        数据结构（节选）::
+        .. code:: json
 
             {
-                "id": 2435521222631982507,
-                "instrument": "BTC",
-                "direction": "short",
-                "openPrice": 88230.5,
-                "currentPiece": 1,
-                "profitUnreal": 0.0086,
-                "status": "open"
-            }
+                "currentPiece": "0",
+                "isProfession": 0,
+                "leverage": "10",
+                "originalType": "execute",
+                "orderId": "33309059291614824",
+                "contractType": 1,
+                "openId": "2435521222638707873",
+                "fee": "0.00020724",
+                "openPrice": "0.3456",
+                "orderStatus": "finish",
+                "instrument": "JUP",
+                "quantityUnit": 1,
+                "source": "api",
+                "updatedDate": 1761192795412,
+                "positionModel": 1,
+                "feeRate": "0.0006",
+                "netProfit": "-0.00040724",
+                "baseSize": "1",
+                "quote": "usdt",
+                "liquidateBy": "manual",
+                "totalPiece": "1",
+                "orderPrice": "0",
+                "id": "23469279597150213",
+                "fundingSettle": "0",
+                "direction": "long",
+                "margin": "0.03435264",
+                "takerMaker": 1,
+                "indexPrice": "0.3455",
+                "quantity": "0.03456",
+                "userId": "1757458",
+                "closedPiece": "1",
+                "createdDate": 1761192793000,
+                "hedgeId": "23469279597150214",
+                "closePrice": "0.3454",
+                "positionMargin": "0.03435264",
+                "base": "jup",
+                "realPrice": "0.3454",
+                "status": "close"
+                }
         """
 
         return self._get("position", Position)

{hyperquant-0.88.dist-info → hyperquant-0.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.88
+Version: 0.91
 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
@@ -12,15 +12,17 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.10.4
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: cryptography>=44.0.2
+Requires-Dist: curl-cffi>=0.13.0
 Requires-Dist: duckdb>=1.2.2
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1
 Requires-Dist: pyecharts>=2.0.8
+Requires-Dist: rnet==3.0.0rc10
 Description-Content-Type: text/markdown
 
 # minquant

{hyperquant-0.88.dist-info → hyperquant-0.91.dist-info}/RECORD

@@ -6,7 +6,8 @@ hyperquant/logkit.py,sha256=nUo7nx5eONvK39GOhWwS41zNRL756P2J7-5xGzwXnTY,8462
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
 hyperquant/broker/auth.py,sha256=xNZEQP0LRRV9BkT2uXBJ-vFfeahUnRVq1bjIT6YbQu8,10089
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
-hyperquant/broker/coinw.py,sha256=hSUdMfezWn2jJ9LGTLMFx6waSTE5kuypINDY1q8us5I,15856
+hyperquant/broker/coinup.py,sha256=tADmydit0_Aspv0747fBUk9ZFRCkkWnb16LBlw2twWQ,20357
+hyperquant/broker/coinw.py,sha256=SnJU0vASh77rfcpMGWaIfTblQSjQk3vjlW_4juYdbcs,17214
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
 hyperquant/broker/lbank.py,sha256=98M5wmSoeHwbBYMA3rh25zqLb6fQKVaEmwqALF5nOvY,22181
@@ -17,7 +18,8 @@ hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb8
 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=XLrARTyT4ClF1SEhaZ9uZHVo7ntAvE7nKxaU_mzVmqU,21949
+hyperquant/broker/models/coinup.py,sha256=1g-peGSpZvVI17IVhu10kjUsZOb14e6q9aa8RL7iDS0,11101
+hyperquant/broker/models/coinw.py,sha256=LvLMVP7i-qkkTK1ubw8eBkMK2RQmFoKPxdKqmC4IToY,22157
 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
@@ -26,6 +28,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.88.dist-info/METADATA,sha256=JGkF-AvAkw1MGD_XnNSS5wR4x9g1etWbmw5ifc36AdI,4317
-hyperquant-0.88.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.88.dist-info/RECORD,,
+hyperquant-0.91.dist-info/METADATA,sha256=5nL2dFJgOtm_XeMbETtaHqppY_Y4wHIrNaMtTEVeF58,4382
+hyperquant-0.91.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.91.dist-info/RECORD,,