hyperquant 0.59__py3-none-any.whl → 0.62__py3-none-any.whl

hyperquant/broker/edgex.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Iterable, Literal
+
+import pybotters
+
+from .models.edgex import EdgexDataStore
+
+
+class Edgex:
+    """
+    Edgex 公共 API (HTTP/WS) 封装。
+
+    说明
+    - 当前仅包含公共行情数据（不包含私有接口）。
+    - 订单簿频道命名规则：``depth.{contractId}.{level}``。
+      成功订阅后，服务器会先推送一次完整快照（depthType=SNAPSHOT），之后持续推送增量（depthType=CHANGED）。
+      解析后的结果存入 ``EdgexDataStore.book``。
+
+    参数
+    - client: ``pybotters.Client`` 实例
+    - api_url: REST 基地址；默认使用 Edgex 官方 testnet 站点
+    - ws_url: WebSocket 基地址；如不提供，则默认使用官方文档地址。
+    """
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        api_url: str | None = None,
+    ) -> None:
+        self.client = client
+        self.store = EdgexDataStore()
+        # 公共端点可能因环境/地区不同而变化，允许外部覆盖。
+        self.api_url = api_url or "https://pro.edgex.exchange"
+        self.ws_url = "wss://quote.edgex.exchange"
+
+    async def __aenter__(self) -> "Edgex":
+        # 初始化基础合约元数据，便于后续使用 tickSize 等字段。
+        await self.update_detail()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: BaseException | None,
+    ) -> None:
+        # Edgex 当前没有需要关闭的资源；保持接口与 Ourbit 等类一致。
+        return None
+
+    async def update_detail(self) -> dict[str, Any]:
+        """Fetch and cache contract metadata via the public REST endpoint."""
+
+        url = self._resolve_api_path("/api/v1/public/meta/getMetaData")
+        res = await self.client.get(url)
+        res.raise_for_status()
+        data = await res.json()
+
+        if data.get("code") != "SUCCESS":  # pragma: no cover - defensive guard
+            raise RuntimeError(f"Failed to fetch Edgex metadata: {data}")
+
+        self.store._apply_metadata(data)
+        return data
+
+    def _resolve_api_path(self, path: str) -> str:
+        base = (self.api_url or "").rstrip("/")
+        return f"{base}{path}"
+
+    async def sub_orderbook(
+        self,
+        contract_ids: str | Iterable[str] | None = None,
+        *,
+        symbols: str | Iterable[str] | None = None,
+        level: int = 15,
+        ws_url: str | None = None,
+    ) -> None:
+        """订阅指定合约 ID 或交易对名的订单簿（遵循 Edgex 协议）。
+
+        规范
+        - 默认 WS 端点：wss://quote.edgex.exchange（可通过参数/实例覆盖）
+        - 每个频道的订阅报文：
+          {"type": "subscribe", "channel": "depth.{contractId}.{level}"}
+        - 服务端在订阅成功后，会先推送一次快照，再持续推送增量。
+        """
+
+        ids: list[str] = []
+        if contract_ids is not None:
+            if isinstance(contract_ids, str):
+                ids.extend([contract_ids])
+            else:
+                ids.extend(contract_ids)
+
+        if symbols is not None:
+            if isinstance(symbols, str):
+                lookup_symbols = [symbols]
+            else:
+                lookup_symbols = list(symbols)
+
+            for symbol in lookup_symbols:
+                matches = self.store.detail.find({"contractName": symbol})
+                if not matches:
+                    raise ValueError(f"Unknown Edgex symbol: {symbol}")
+                ids.append(str(matches[0]["contractId"]))
+
+        if not ids:
+            raise ValueError("contract_ids or symbols must be provided")
+
+        channels = [f"depth.{cid}.{level}" for cid in ids]
+
+        # 优先使用参数 ws_url，其次使用实例的 ws_url，最后使用默认地址。
+        url =  f"{self.ws_url}/api/v1/public/ws?timestamp=" + str(int(time.time() * 1000))
+
+        # 根据文档：每个频道一条订阅指令，允许一次发送多个订阅对象。
+        payload = [{"type": "subscribe", "channel": ch} for ch in channels]
+
+        wsapp = self.client.ws_connect(url, send_json=payload, hdlr_json=self.store.onmessage)
+        # 等待 WS 完成握手再返回，确保订阅报文成功发送。
+        await wsapp._event.wait()
+
+    async def sub_ticker(
+        self,
+        contract_ids: str | Iterable[str] | None = None,
+        *,
+        symbols: str | Iterable[str] | None = None,
+        all_contracts: bool = False,
+        periodic: bool = False,
+        ws_url: str | None = None,
+    ) -> None:
+        """订阅 24 小时行情推送。
+
+        参数
+        - contract_ids / symbols: 指定单个或多个合约；二者至少提供一个。
+        - all_contracts: 订阅 ``ticker.all``（或 ``ticker.all.1s``）。
+        - periodic: 与 ``all_contracts`` 配合，true 则订阅 ``ticker.all.1s``。
+        """
+
+        channels: list[str] = []
+
+        if all_contracts:
+            channel = "ticker.all.1s" if periodic else "ticker.all"
+            channels.append(channel)
+        else:
+            ids: list[str] = []
+            if contract_ids is not None:
+                if isinstance(contract_ids, str):
+                    ids.append(contract_ids)
+                else:
+                    ids.extend(contract_ids)
+
+            if symbols is not None:
+                if isinstance(symbols, str):
+                    lookup_symbols = [symbols]
+                else:
+                    lookup_symbols = list(symbols)
+
+                for symbol in lookup_symbols:
+                    matches = self.store.detail.find({"contractName": symbol})
+                    if not matches:
+                        raise ValueError(f"Unknown Edgex symbol: {symbol}")
+                    ids.append(str(matches[0]["contractId"]))
+
+            if not ids:
+                raise ValueError("Provide contract_ids/symbols or set all_contracts=True")
+
+            channels.extend(f"ticker.{cid}" for cid in ids)
+
+        url = ws_url or f"{self.ws_url}/api/v1/public/ws?timestamp=" + str(int(time.time() * 1000))
+        payload = [{"type": "subscribe", "channel": ch} for ch in channels]
+
+        wsapp = self.client.ws_connect(url, send_json=payload, hdlr_json=self.store.onmessage)
+        await wsapp._event.wait()
+
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: BaseException | None,
+    ) -> None:
+        # Edgex 当前没有需要关闭的资源；保持接口与 Ourbit 等类一致。
+        return None

hyperquant/broker/lbank.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import logging
+import time
+import zlib
+from typing import Iterable, Literal
+
+import pybotters
+
+from .models.lbank import LbankDataStore
+
+logger = logging.getLogger(__name__)
+
+# https://ccapi.rerrkvifj.com 似乎是spot的api
+# https://uuapi.rerrkvifj.com 似乎是合约的api
+
+
+class Lbank:
+    """LBank public market-data client (REST + WS)."""
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        front_api: str | None = None,
+        rest_api: str | None = None,
+        ws_url: str | None = None,
+    ) -> None:
+        self.client = client
+        self.store = LbankDataStore()
+        self.front_api = front_api or "https://uuapi.rerrkvifj.com"
+        self.rest_api = rest_api or "https://api.lbkex.com"
+        self.ws_url = ws_url or "wss://uuws.rerrkvifj.com/ws/v3"
+        self._req_id = itertools.count(int(time.time() * 1000))
+        self._ws_app = None
+
+    async def __aenter__(self) -> "Lbank":
+        await self.update("detail")
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        pass
+
+    async def update(self, update_type: Literal["detail", "ticker", "all"]) -> list[dict]:
+        all_urls = [f"{self.front_api}/cfd/agg/v1/instrument"]
+        url_map = {"detail": [all_urls[0]], "all": all_urls}
+
+
+        try:
+            urls = url_map[update_type]
+        except KeyError:
+            raise ValueError(f"update_type err: {update_type}")
+
+        # await self.store.initialize(*(self.client.get(url) for url in urls))
+        if update_type == "detail" or update_type == "all":
+            await self.store.initialize(
+                self.client.post(
+                    all_urls[0],
+                    json={"ProductGroup": "SwapU"},
+                    headers={"source": "4", "versionflage": "true"},
+                )
+            )
+
+
+    async def sub_orderbook(self, symbols: list[str], limit: int | None = None) -> None:
+        """订阅指定交易对的订单簿（遵循 LBank 协议）。
+        """
+
+        send_jsons = []
+        y = 3000000001
+        if limit:
+            self.store.book.limit = limit
+
+        for symbol in symbols:
+
+            info = self.store.detail.get({"symbol": symbol})
+            if not info:
+                raise ValueError(f"Unknown LBank symbol: {symbol}")
+            
+            tick_size = info['tick_size']
+            sub_i = symbol + "_" + str(tick_size) + "_25"
+            send_jsons.append(
+                {
+                    "x": 3,
+                    "y": str(y),
+                    "a": {"i": sub_i},
+                    "z": 1,
+                }
+            )
+
+            self.store.register_book_channel(str(y), symbol)
+            y += 1
+
+        wsapp = self.client.ws_connect(
+            self.ws_url,
+            send_json=send_jsons,
+            hdlr_bytes=self.store.onmessage,
+        )
+
+        await wsapp._event.wait()

hyperquant/broker/models/edgex.py

@@ -0,0 +1,518 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Awaitable, TYPE_CHECKING
+
+from aiohttp import ClientResponse
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+class Book(DataStore):
+    """Order book data store for the Edgex websocket feed."""
+
+    _KEYS = ["c", "S", "p"]
+
+    def _init(self) -> None:
+        self._version: int | str | None = None
+        self.limit: int | None = None
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        content = msg.get("content") or {}
+        entries = content.get("data") or []
+        data_type = (content.get("dataType") or "").lower()
+
+        for entry in entries:
+            contract_id = entry.get("contractId")
+            if contract_id is None:
+                continue
+
+            contract_name = entry.get("contractName")
+            end_version = entry.get("endVersion")
+            depth_type = (entry.get("depthType") or "").lower()
+
+            is_snapshot = data_type == "snapshot" or depth_type == "snapshot"
+
+            if is_snapshot:
+                self._handle_snapshot(
+                    contract_id,
+                    contract_name,
+                    entry,
+                )
+            else:
+                self._handle_delta(
+                    contract_id,
+                    contract_name,
+                    entry,
+                )
+
+            if end_version is not None:
+                self._version = self._normalize_version(end_version)
+
+    def _handle_snapshot(
+        self,
+        contract_id: str,
+        contract_name: str | None,
+        entry: dict[str, Any],
+    ) -> None:
+        asks = entry.get("asks") or []
+        bids = entry.get("bids") or []
+
+        self._find_and_delete({"c": contract_id})
+
+        payload: list[dict[str, Any]] = []
+        payload.extend(
+            self._build_items(
+                contract_id,
+                contract_name,
+                "a",
+                asks,
+            )
+        )
+        payload.extend(
+            self._build_items(
+                contract_id,
+                contract_name,
+                "b",
+                bids,
+            )
+        )
+
+        if payload:
+            self._insert(payload)
+            self._trim(contract_id, contract_name)
+
+    def _handle_delta(
+        self,
+        contract_id: str,
+        contract_name: str | None,
+        entry: dict[str, Any],
+    ) -> None:
+        updates: list[dict[str, Any]] = []
+        deletes: list[dict[str, Any]] = []
+
+        asks = entry.get("asks") or []
+        bids = entry.get("bids") or []
+
+        for side, levels in (("a", asks), ("b", bids)):
+            for row in levels:
+                price, size = self._extract_price_size(row)
+                criteria = {"c": contract_id, "S": side, "p": price}
+
+                if not size or float(size) == 0.0:
+                    deletes.append(criteria)
+                    continue
+
+                updates.append(
+                    {
+                        "c": contract_id,
+                        "S": side,
+                        "p": price,
+                        "q": size,
+                        "s": self._symbol(contract_id, contract_name),
+                    }
+                )
+
+        if deletes:
+            self._delete(deletes)
+        if updates:
+            self._update(updates)
+            self._trim(contract_id, contract_name)
+        
+
+    def _build_items(
+        self,
+        contract_id: str,
+        contract_name: str | None,
+        side: str,
+        rows: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        for row in rows:
+            price, size = self._extract_price_size(row)
+            if not size or float(size) == 0.0:
+                continue
+            items.append(
+                {
+                    "c": contract_id,
+                    "S": side,
+                    "p": price,
+                    "q": size,
+                    "s": self._symbol(contract_id, contract_name),
+                }
+            )
+        return items
+
+    @staticmethod
+    def _normalize_version(value: Any) -> int | str:
+        if value is None:
+            return value
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return str(value)
+
+    @staticmethod
+    def _to_str(value: Any) -> str | None:
+        if value is None:
+            return None
+        return str(value)
+
+    @staticmethod
+    def _extract_price_size(row: dict[str, Any]) -> tuple[str, str]:
+        return str(row["price"]), str(row["size"])
+
+    def _trim(self, contract_id: str, contract_name: str | None) -> None:
+        if self.limit is None:
+            return
+
+        query: dict[str, Any]
+        symbol = self._symbol(contract_id, contract_name)
+        if symbol:
+            query = {"s": symbol}
+        else:
+            query = {"c": contract_id}
+
+        sort_data = self.sorted(query, self.limit)
+        asks = sort_data.get("a", [])
+        bids = sort_data.get("b", [])
+
+        self._find_and_delete(query)
+
+        trimmed = asks + bids
+        if trimmed:
+            self._insert(trimmed)
+
+    @staticmethod
+    def _symbol(contract_id: str, contract_name: str | None) -> str:
+        if contract_name:
+            return str(contract_name)
+        return str(contract_id)
+
+    @property
+    def version(self) -> int | str | None:
+        """返回当前缓存的订单簿版本号。"""
+        return self._version
+
+    def sorted(
+        self,
+        query: dict[str, Any] | None = None,
+        limit: int | None = None,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """按买卖方向与价格排序后的订单簿视图。"""
+        return self._sorted(
+            item_key="S",
+            item_asc_key="a",
+            item_desc_key="b",
+            sort_key="p",
+            query=query,
+            limit=limit,
+        )
+
+
+class Ticker(DataStore):
+    """24 小时行情推送数据。"""
+
+    _KEYS = ["c"]
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        content = msg.get("content") or {}
+        entries = content.get("data") or []
+        data_type = (content.get("dataType") or "").lower()
+
+        for entry in entries:
+            item = self._format(entry)
+            if item is None:
+                continue
+
+            criteria = {"c": item["c"]}
+            if data_type == "snapshot":
+                self._find_and_delete(criteria)
+                self._insert([item])
+            else:
+                self._update([item])
+
+    def _format(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        contract_id = entry.get("contractId")
+        if contract_id is None:
+            return None
+
+        item: dict[str, Any] = {"c": str(contract_id)}
+
+        name = entry.get("contractName")
+        if name is not None:
+            item["s"] = str(name)
+
+        fields = [
+            "priceChange",
+            "priceChangePercent",
+            "trades",
+            "size",
+            "value",
+            "high",
+            "low",
+            "open",
+            "close",
+            "highTime",
+            "lowTime",
+            "startTime",
+            "endTime",
+            "lastPrice",
+            "indexPrice",
+            "oraclePrice",
+            "openInterest",
+            "fundingRate",
+            "fundingTime",
+            "nextFundingTime",
+            "bestAskPrice",
+            "bestBidPrice",
+        ]
+
+        for key in fields:
+            value = entry.get(key)
+            if value is not None:
+                item[key] = str(value)
+
+        return item
+
+
+class CoinMeta(DataStore):
+    """Coin metadata (precision, StarkEx info, etc.)."""
+
+    _KEYS = ["coinId"]
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        coins = (data.get("data") or {}).get("coinList") or []
+        items: list[dict[str, Any]] = []
+
+        for coin in coins:
+            coin_id = coin.get("coinId")
+            if coin_id is None:
+                continue
+            items.append(
+                {
+                    "coinId": str(coin_id),
+                    "coinName": coin.get("coinName"),
+                    "stepSize": coin.get("stepSize"),
+                    "showStepSize": coin.get("showStepSize"),
+                    "starkExAssetId": coin.get("starkExAssetId"),
+                }
+            )
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+class ContractMeta(DataStore):
+    """Per-contract trading parameters from the metadata endpoint."""
+
+    _KEYS = ["contractId"]
+
+    _FIELDS = (
+        "contractName",
+        "baseCoinId",
+        "quoteCoinId",
+        "tickSize",
+        "stepSize",
+        "minOrderSize",
+        "maxOrderSize",
+        "defaultTakerFeeRate",
+        "defaultMakerFeeRate",
+        "enableTrade",
+        "fundingInterestRate",
+        "fundingImpactMarginNotional",
+        "fundingRateIntervalMin",
+        "starkExSyntheticAssetId",
+        "starkExResolution",
+    )
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        contracts = (data.get("data") or {}).get("contractList") or []
+        items: list[dict[str, Any]] = []
+
+        for contract in contracts:
+            contract_id = contract.get("contractId")
+            if contract_id is None:
+                continue
+
+            payload = {"contractId": str(contract_id)}
+            for key in self._FIELDS:
+                payload[key] = contract.get(key)
+            payload["riskTierList"] = self._simplify_risk_tiers(contract.get("riskTierList"))
+
+            items.append(payload)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+    @staticmethod
+    def _simplify_risk_tiers(risk_tiers: Any) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        for tier in risk_tiers or []:
+            items.append(
+                {
+                    "tier": tier.get("tier"),
+                    "positionValueUpperBound": tier.get("positionValueUpperBound"),
+                    "maxLeverage": tier.get("maxLeverage"),
+                    "maintenanceMarginRate": tier.get("maintenanceMarginRate"),
+                    "starkExRisk": tier.get("starkExRisk"),
+                    "starkExUpperBound": tier.get("starkExUpperBound"),
+                }
+            )
+        return items
+
+class EdgexDataStore(DataStoreCollection):
+    """Edgex DataStore collection exposing the order book feed."""
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("ticker", datastore_class=Ticker)
+        self._create("meta_coin", datastore_class=CoinMeta)
+        self._create("detail", datastore_class=ContractMeta)
+
+    @property
+    def book(self) -> Book:
+        """
+        获取 Edgex 合约订单簿数据流。
+
+        .. code:: json
+
+            [
+                {
+                    "c": "10000001",        # 合约 ID
+                    "s": "BTCUSD",
+                    "S": "a",               # 方向 a=卖 b=买
+                    "p": "117388.2",        # 价格
+                    "q": "12.230",          # 数量
+                }
+            ]
+        """
+        return self._get("book")
+
+
+
+    @property
+    def coins(self) -> CoinMeta:
+        """
+        获取币种精度及 StarkEx 资产信息列表。
+
+        .. code:: json
+
+            [
+                {
+                    "coinId": "1000",
+                    "coinName": "USDT",
+                    "stepSize": "0.000001",
+                    "showStepSize": "0.0001",
+                    "starkExAssetId": "0x33bda5c9..."
+                }
+            ]
+        """
+        return self._get("meta_coin")
+
+    @property
+    def detail(self) -> ContractMeta:
+        """
+        获取合约级别的交易参数。
+
+        .. code:: json
+
+            [
+                {
+                    "contractId": "10000001",
+                    "contractName": "BTCUSDT",
+                    "baseCoinId": "1001",
+                    "quoteCoinId": "1000",
+                    "tickSize": "0.1",
+                    "stepSize": "0.001",
+                    "minOrderSize": "0.001",
+                    "maxOrderSize": "50.000",
+                    "defaultMakerFeeRate": "0.0002",
+                    "defaultTakerFeeRate": "0.00055",
+                    "enableTrade": true,
+                    "fundingInterestRate": "0.0003",
+                    "fundingImpactMarginNotional": "10",
+                    "fundingRateIntervalMin": "240",
+                    "starkExSyntheticAssetId": "0x42544332...",
+                    "starkExResolution": "0x2540be400",
+                    "riskTierList": [
+                        {
+                            "tier": 1,
+                            "positionValueUpperBound": "50000",
+                            "maxLeverage": "100",
+                            "maintenanceMarginRate": "0.005",
+                            "starkExRisk": "21474837",
+                            "starkExUpperBound": "214748364800000000000"
+                        }
+                    ]
+                }
+            ]
+        """
+        return self._get("detail")
+
+    @property
+    def ticker(self) -> Ticker:
+        """
+        获取 24 小时行情推送。
+
+        .. code:: json
+
+            [
+                {
+                    "c": "10000001",      # 合约 ID
+                    "s": "BTCUSD",        # 合约名称
+                    "lastPrice": "117400",  # 最新价
+                    "priceChange": "200",   # 涨跌额
+                    "priceChangePercent": "0.0172",  # 涨跌幅
+                    "size": "1250",        # 24h 成交量
+                    "value": "147000000", # 24h 成交额
+                    "high": "118000",      # 24h 最高价
+                    "low": "116500",       # 低价
+                    "open": "116800",      # 开盘价
+                    "close": "117400",     # 收盘价
+                    "indexPrice": "117350", # 指数价
+                    "oraclePrice": "117360.12", # 预言机价
+                    "openInterest": "50000",    # 持仓量
+                    "fundingRate": "0.000234",  # 当前资金费率
+                    "fundingTime": "1758240000000", # 上一次结算时间
+                    "nextFundingTime": "1758254400000", # 下一次结算时间
+                    "bestAskPrice": "117410",    # 卖一价
+                    "bestBidPrice": "117400"     # 买一价
+                }
+            ]
+        """
+        return self._get("ticker")
+
+    async def initialize(self, *aws: Awaitable["ClientResponse"]) -> None:
+        """Populate metadata stores from awaited HTTP responses."""
+
+        for fut in asyncio.as_completed(aws):
+            res = await fut
+            data = await res.json()
+            if res.url.path == "/api/v1/public/meta/getMetaData":
+                self._apply_metadata(data)
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        channel = (msg.get("channel") or "").lower()
+        msg_type = (msg.get("type") or "").lower()
+
+        if msg_type == "ping" and ws is not None:
+            payload = {"type": "pong", "time": msg.get("time")}
+            asyncio.create_task(ws.send_json(payload))
+            return
+
+        if "depth" in channel and msg_type in {"quote-event", "payload"}:
+            self.book._on_message(msg)
+
+        if channel.startswith("ticker") and msg_type in {"payload", "quote-event"}:
+            self.ticker._on_message(msg)
+
+
+    def _apply_metadata(self, data: dict[str, Any]) -> None:
+        self.coins._onresponse(data)
+        self.detail._onresponse(data)

hyperquant/broker/models/lbank.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Awaitable, TYPE_CHECKING
+
+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__)
+
+
+def _accuracy_to_step(accuracy: int | str | None) -> str:
+    try:
+        n = int(accuracy) if accuracy is not None else 0
+    except (TypeError, ValueError):  # pragma: no cover - defensive guard
+        n = 0
+    if n <= 0:
+        return "1"
+    return "0." + "0" * (n - 1) + "1"
+
+
+class Book(DataStore):
+    """LBank order book store parsed from the depth channel."""
+
+    _KEYS = ["id", "S", "p"]
+
+    def _init(self) -> None:
+        self.limit: int | None = None
+        self.symbol_map: dict[str, str] = {}
+
+
+    def _format_levels(
+        self,
+        levels: list[list[Any]],
+        channel_id: str | None,
+        side: str,
+        symbol: str | None,
+    ) -> list[dict[str, Any]]:
+        formatted: list[dict[str, Any]] = []
+        for level in levels:
+            if len(level) < 2:
+                continue
+            try:
+                price = float(level[0])
+                size = float(level[1])
+            except (TypeError, ValueError):  # pragma: no cover - defensive guard
+                continue
+            formatted.append(
+                {
+                    "id": channel_id,
+                    "S": side,
+                    "p": price,
+                    "q": size,
+                    "s": symbol,
+                }
+            )
+        if self.limit is not None:
+            formatted = formatted[: self.limit]
+        return formatted
+
+    def _on_message(self, msg: Any) -> None:
+        
+        data = json.loads(msg)
+        
+        if not data:
+            return
+
+        channel_id = None
+        if data.get("y") is not None:
+            channel_id = str(data["y"])
+
+        symbol = None
+        if channel_id:
+            symbol = self.symbol_map.get(channel_id)
+        if symbol is None and data.get("i"):
+            symbol = self.symbol_map.get(str(data["i"]))
+
+        bids = self._format_levels(data.get("b", []), channel_id, "b", symbol)
+        asks = self._format_levels(data.get("s", []), channel_id, "a", symbol)
+
+        if not (bids or asks):
+            return
+
+        if channel_id is not None:
+            self._find_and_delete({"id": channel_id})
+        self._insert(bids + asks)
+
+
+class Detail(DataStore):
+    """Futures instrument metadata store obtained from the futures instrument endpoint."""
+
+    _KEYS = ["symbol"]
+
+    def _transform(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        try:
+            instrument:dict = entry["instrument"]
+            fee:dict = entry["fee"]
+            market_data:dict = entry["marketData"]
+        except (KeyError, TypeError):
+            return None
+        return {
+            "symbol": instrument.get("instrumentID"),
+            "instrument_name": instrument.get("instrumentName"),
+            "base_currency": instrument.get("baseCurrency"),
+            "price_currency": instrument.get("priceCurrency"),
+            "min_order_volume": instrument.get("minOrderVolume"),
+            "max_order_volume": instrument.get("maxOrderVolume"),
+            "tick_size": instrument.get("priceTick"),
+            "step_size": instrument.get("volumeTick"),
+            "maker_fee": fee.get("makerOpenFeeRate"),
+            "taker_fee": fee.get("takerOpenFeeRate"),
+            "last_price": market_data.get("lastPrice"),
+            "amount24": market_data.get("turnover24"),
+        }
+
+    def _onresponse(self, data: list[dict[str, Any]] | dict[str, Any] | None) -> None:
+        if not data:
+            self._clear()
+            return
+        entries = data
+        if isinstance(data, dict):  # pragma: no cover - defensive guard
+            entries = data.get("data") or []
+        items: list[dict[str, Any]] = []
+        for entry in entries or []:
+            transformed = self._transform(entry)
+            if transformed:
+                items.append(transformed)
+        if not items:
+            self._clear()
+            return
+        self._clear()
+        self._insert(items)
+
+
+class LbankDataStore(DataStoreCollection):
+    """Aggregates book/detail stores for the LBank public feed."""
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._channel_to_symbol: dict[str, str] = {}
+
+    @property
+    def book(self) -> Book:
+        """
+        订单簿（Order Book）数据流，按订阅ID（channel_id）索引。
+
+        此属性表示通过深度频道（depth channel）接收到的订单簿快照和增量更新，数据结构示例如下：
+
+        Data structure:
+            [
+                {
+                    "id": <channel_id>,
+                    "S": "b" 或 "a",  # "b" 表示买单，"a" 表示卖单
+                    "p": <价格>,
+                    "q": <数量>,
+                    "s": <标准化交易对符号>
+                },
+                ...
+            ]
+
+        通过本属性可以获取当前 LBank 订单簿的最新状态，便于后续行情分析和撮合逻辑处理。
+        """
+        return self._get("book")
+
+    @property
+    def detail(self) -> Detail:
+        """
+
+        _KEYS = ["symbol"]
+
+        期货合约详情元数据流。
+
+        此属性表示通过期货合约接口获取的合约详情，包括合约ID、合约名称、基础币种、计价币种、最小/最大下单量、价格跳动、交易量跳动、maker/taker手续费率、最新价和24小时成交额等信息。
+
+        Data structure:
+            [
+                {
+                    "symbol": "BTCUSDT",               # 合约ID
+                    "instrument_name": "BTCUSDT",      # 合约名称
+                    "base_currency": "BTC",            # 基础币种
+                    "price_currency": "USDT",          # 计价币种
+                    "min_order_volume": "0.0001",        # 最小下单量
+                    "max_order_volume": "600.0",         # 最大下单量
+                    "tick_size": "0.1",                  # 最小价格变动单位
+                    "step_size": "0.0001",               # 最小数量变动单位
+                    "maker_fee": "0.0002",               # Maker 手续费率
+                    "taker_fee": "0.0006",               # Taker 手续费率
+                    "last_price": "117025.5",            # 最新价
+                    "amount24": "807363493.97579747"     # 24小时成交额
+                },
+                ...
+            ]
+
+        通过本属性可以获取所有支持的期货合约元数据，便于下单参数校验和行情展示。
+        """
+        return self._get("detail")
+
+
+    def register_book_channel(self, channel_id: str, symbol: str, *, raw_symbol: str | None = None) -> None:
+        if channel_id is not None:
+            self.book.symbol_map[str(channel_id)] = symbol
+        if raw_symbol:
+            self.book.symbol_map[str(raw_symbol)] = symbol
+
+
+    async def initialize(self, *aws: Awaitable[ClientResponse]) -> None:
+        for fut in asyncio.as_completed(aws):
+            res = await fut
+            data = await res.json()
+            if res.url.path == "/cfd/agg/v1/instrument":
+                self.detail._onresponse(data)
+
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        self.book._on_message(msg)

hyperquant/broker/models/ourbit.py

@@ -80,7 +80,6 @@ class Book(DataStore):
         """返回最后更新时间"""
         return self._time
 
-    @property
     def sorted(        
         self, query: Item | None = None, limit: int | None = None
     ) -> dict[str, list[Item]]:

hyperquant/broker/ws.py

@@ -1,4 +1,6 @@
 import asyncio
+import time
+
 import pybotters
 from pybotters.ws import ClientWebSocketResponse, logger
 from pybotters.auth import Hosts
@@ -17,8 +19,16 @@ class Heartbeat:
             await ws.send_str('{"method":"ping"}')
             await asyncio.sleep(10.0)
 
+    @staticmethod
+    async def edgex(ws: pybotters.ws.ClientWebSocketResponse):
+        while not ws.closed:
+            now = str(int(time.time() * 1000))
+            await ws.send_json({"type": "ping", "time": now})
+            await asyncio.sleep(20.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
 
 class WssAuth:
     @staticmethod

{hyperquant-0.59.dist-info → hyperquant-0.62.dist-info}/METADATA

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

@@ -5,17 +5,21 @@ 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=oA9Yw1I59-u0Tnoj2e4wUup5q8V5T2qpga5RKbiAiZI,2614
+hyperquant/broker/edgex.py,sha256=qQtc8jZqB5ZODoGGVcG_aIVUlrJX_pRF9EyO927LiVM,6646
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
+hyperquant/broker/lbank.py,sha256=e-DnZg-rBwpTV7FWmPpG89Y7kk7NZOzilvEn7V3LEI0,2978
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
-hyperquant/broker/ws.py,sha256=umRzxwCaZaRIgIq4YY-AuA0wCXFT0uOBmQbIXFY8CK0,1555
+hyperquant/broker/ws.py,sha256=Ce5-g2BWhS8ZmVoLjtSj3Eb1TNIN4pgEIyJ0ODjiwUo,1902
 hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb84D8,8296
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
+hyperquant/broker/models/edgex.py,sha256=texNBwz_9r9CTl7dRNjvSm_toxV_og0TWnap3dqUk2s,15795
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
-hyperquant/broker/models/ourbit.py,sha256=6j6wc2QQsn25hpRk_yVGJm-v_YyiHh-Yq6VNWt39mkY,41979
+hyperquant/broker/models/lbank.py,sha256=_P0oRPID2Yd_cpElHa3QIT471YlfIzexXMrzm1WVnHI,7652
+hyperquant/broker/models/ourbit.py,sha256=xMcbuCEXd3XOpPBq0RYF2zpTFNnxPtuNJZCexMZVZ1k,41965
 hyperquant/datavison/_util.py,sha256=92qk4vO856RqycO0YqEIHJlEg-W9XKapDVqAMxe6rbw,533
 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.59.dist-info/METADATA,sha256=2AsJ7yBJN3HSrPXOAOmTOJNWAW2-7K0G-Xj5-26Hci0,4317
-hyperquant-0.59.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.59.dist-info/RECORD,,
+hyperquant-0.62.dist-info/METADATA,sha256=cjL0r-jaGJWLIgCAXp-6RzRUdac8ec_bjEKJ2WtSCoo,4317
+hyperquant-0.62.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.62.dist-info/RECORD,,