hyperquant 0.59__py3-none-any.whl → 0.61__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/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/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.61.dist-info}/METADATA

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

@@ -5,17 +5,19 @@ 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/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/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.61.dist-info/METADATA,sha256=R8ITR5IGZHsDFVEG982ItyBnYhMolLcy8ZZxGcptE4w,4317
+hyperquant-0.61.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.61.dist-info/RECORD,,