hyperquant 0.66__py3-none-any.whl → 0.68__py3-none-any.whl

hyperquant/broker/auth.py

@@ -170,6 +170,33 @@ class Auth:
         headers.update({"cookie": cookie})
         return args
 
+    @staticmethod
+    def lbank(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        data = kwargs.get("data") or {}
+        headers: CIMultiDict = kwargs["headers"]
+
+        # 从 session 里取 api_key & secret
+        session = kwargs["session"]
+        token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
+
+
+        # 设置 headers
+        headers.update(
+            {
+                "ex-language": 'zh-TW',
+                "ex-token": token,
+                "source": "4",
+                "versionflage": "true",
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0"
+            }
+        )
+
+        # 更新 kwargs.body，保证发出去的与签名一致
+        # kwargs.update({"data": raw_body_for_sign})
+
+        return args
 
 pybotters.auth.Hosts.items["futures.ourbit.com"] = pybotters.auth.Item(
     "ourbit", Auth.ourbit
@@ -178,6 +205,10 @@ pybotters.auth.Hosts.items["www.ourbit.com"] = pybotters.auth.Item(
     "ourbit", Auth.ourbit_spot
 )
 
+pybotters.auth.Hosts.items["www.ourbit.com"] = pybotters.auth.Item(
+    "ourbit", Auth.ourbit_spot
+)
+
 pybotters.auth.Hosts.items["pro.edgex.exchange"] = pybotters.auth.Item(
     "edgex", Auth.edgex
 )
@@ -185,4 +216,8 @@ pybotters.auth.Hosts.items["pro.edgex.exchange"] = pybotters.auth.Item(
 
 pybotters.auth.Hosts.items["quote.edgex.exchange"] = pybotters.auth.Item(
     "edgex", Auth.edgex
+)
+
+pybotters.auth.Hosts.items["uuapi.rerrkvifj.com"] = pybotters.auth.Item(
+    "lbank", Auth.lbank
 )

hyperquant/broker/edgex.py

@@ -126,29 +126,41 @@ class Edgex:
 
     async def update(
         self,
-        update_type: Literal["balance", "position", "orders", "all"] = "all",
-    ):
-        """使用 REST 刷新本地缓存的账户资产、持仓及活动订单。"""
+        update_type: Literal["balance", "position", "orders", "ticker", "all"] = "all",
+        *,
+        contract_id: str | None = None,
+    ) -> None:
+        """使用 REST 刷新本地缓存的账户资产、持仓、活动订单与 24h 行情。"""
 
-        if not getattr(self, "accountid", None):
+        requires_account = {"balance", "position", "orders", "all"}
+        if update_type in requires_account and not getattr(self, "accountid", None):
             raise ValueError("accountid not set; call sync_user() before update().")
 
-        account_asset_url = (
-            f"{self.api_url}/api/v1/private/account/getAccountAsset"
-            f"?accountId={self.accountid}"
-        )
-        active_orders_url = (
-            f"{self.api_url}/api/v1/private/order/getActiveOrderPage"
-            f"?accountId={self.accountid}&size=200"
-        )
-
-        all_urls = [account_asset_url, active_orders_url]
-
-        url_map = {
-            "balance": [account_asset_url],
-            "position": [account_asset_url],
-            "orders": [active_orders_url],
-            "all": all_urls,
+        account_asset_url = None
+        active_orders_url = None
+        if update_type in requires_account:
+            account_asset_url = (
+                f"{self.api_url}/api/v1/private/account/getAccountAsset"
+                f"?accountId={self.accountid}"
+            )
+            active_orders_url = (
+                f"{self.api_url}/api/v1/private/order/getActiveOrderPage"
+                f"?accountId={self.accountid}&size=200"
+            )
+
+        ticker_url = f"{self.api_url}/api/v1/public/quote/getTicker"
+        if contract_id:
+            ticker_url = f"{ticker_url}?contractId={contract_id}"
+
+        url_map: dict[str, list[str]] = {
+            "balance": [account_asset_url] if account_asset_url else [],
+            "position": [account_asset_url] if account_asset_url else [],
+            "orders": [active_orders_url] if active_orders_url else [],
+            "ticker": [ticker_url],
+            "all": [
+                *(url for url in (account_asset_url, active_orders_url) if url),
+                ticker_url,
+            ],
         }
 
         try:
@@ -261,7 +273,7 @@ class Edgex:
 
         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]
-
+        print(payload)
         wsapp = self.client.ws_connect(url, send_json=payload, hdlr_json=self.store.onmessage)
         await wsapp._event.wait()
 
@@ -448,8 +460,8 @@ class Edgex:
         if data.get("code") != "SUCCESS":  # pragma: no cover - defensive guard
             raise RuntimeError(f"Failed to place Edgex order: {data}")
 
-        # latency = int(data.get("responseTime",0)) - int(data.get("requestTime",0))
-
+        latency = int(data.get("responseTime",0)) - int(data.get("requestTime",0))
+        print(latency)
         order_id = data.get("data", {}).get("orderId")
         return order_id
     

hyperquant/broker/lbank.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import itertools
-import json
 import logging
 import time
-import zlib
-from typing import Iterable, Literal
+from typing import Any, Iterable, Literal
 
 import pybotters
 
 from .models.lbank import LbankDataStore
+from .lib.util import fmt_value
 
 logger = logging.getLogger(__name__)
 
@@ -36,6 +35,7 @@ class Lbank:
         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
+        self._rest_headers = {"source": "4", "versionflage": "true"}
 
     async def __aenter__(self) -> "Lbank":
         await self.update("detail")
@@ -44,26 +44,269 @@ class Lbank:
     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}
+    async def update(
+        self,
+        update_type: Literal["detail", "balance", "position", "orders", "orders_finish", "all"] = "all",
+        *,
+        product_group: str = "SwapU",
+        exchange_id: str = "Exchange",
+        asset: str = "USDT",
+        instrument_id: str | None = None,
+        page_index: int = 1,
+        page_size: int = 1000,
+    ) -> None:
+        """Refresh local caches via REST endpoints.
 
+        Parameters mirror the documented REST API default arguments.
+        """
 
-        try:
-            urls = url_map[update_type]
-        except KeyError:
-            raise ValueError(f"update_type err: {update_type}")
+        requests: list[Any] = []
+
+        include_detail = update_type in {"detail", "all"}
+        include_orders = update_type in {"orders", "all"}
+        include_position = update_type in {"position", "all"}
+        include_balance = update_type in {"balance", "all"}
 
-        # await self.store.initialize(*(self.client.get(url) for url in urls))
-        if update_type == "detail" or update_type == "all":
-            await self.store.initialize(
+        if update_type == "orders_finish":
+            await self.update_finish_order(
+                product_group=product_group,
+                page_index=page_index,
+                page_size=page_size,
+            )
+            return
+
+        if include_detail:
+            requests.append(
                 self.client.post(
-                    all_urls[0],
-                    json={"ProductGroup": "SwapU"},
-                    headers={"source": "4", "versionflage": "true"},
+                    f"{self.front_api}/cfd/agg/v1/instrument",
+                    json={"ProductGroup": product_group},
+                    headers=self._rest_headers,
+                )
+            )
+
+        if include_orders:
+            requests.append(
+                self.client.get(
+                    f"{self.front_api}/cfd/query/v1.0/Order",
+                    params={
+                        "ProductGroup": product_group,
+                        "ExchangeID": exchange_id,
+                        "pageIndex": page_index,
+                        "pageSize": page_size,
+                    },
+                    headers=self._rest_headers,
+                )
+            )
+        
+        if include_position:
+            requests.append(
+                self.client.get(
+                    f"{self.front_api}/cfd/query/v1.0/Position",
+                    params={
+                        "ProductGroup": product_group,
+                        "Valid": 1,
+                        "pageIndex": page_index,
+                        "pageSize": page_size,
+                    },
+                    headers=self._rest_headers,
                 )
             )
 
+        if include_balance:
+            resolved_instrument = instrument_id or self._resolve_instrument()
+            if not resolved_instrument:
+                raise ValueError(
+                    "instrument_id is required to query balance; call update('detail') first or provide instrument_id explicitly."
+                )
+            self.store.balance.set_asset(asset)
+            requests.append(
+                self.client.post(
+                    f"{self.front_api}/cfd/agg/v1/sendQryAll",
+                    json={
+                        "productGroup": product_group,
+                        "instrumentID": resolved_instrument,
+                        "asset": asset,
+                    },
+                    headers=self._rest_headers,
+                )
+            )
+
+        if not requests:
+            raise ValueError(f"update_type err: {update_type}")
+
+        await self.store.initialize(*requests)
+
+    def _resolve_instrument(self) -> str | None:
+        detail_entries = self.store.detail.find()
+        if detail_entries:
+            return detail_entries[0].get("symbol")
+        return None
+
+    def _get_detail_entry(self, symbol: str) -> dict[str, Any]:
+        detail = self.store.detail.get({"symbol": symbol})
+        if not detail:
+            raise ValueError(f"Unknown LBank instrument: {symbol}")
+        return detail
+
+    @staticmethod
+    def _format_with_step(value: float, step: Any) -> str:
+        try:
+            step_float = float(step)
+        except (TypeError, ValueError):  # pragma: no cover - defensive guard
+            step_float = 0.0
+
+        if step_float <= 0:
+            return str(value)
+
+        return fmt_value(value, step_float)
+
+    async def update_finish_order(
+        self,
+        *,
+        product_group: str = "SwapU",
+        page_index: int = 1,
+        page_size: int = 200,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        instrument_id: str | None = None,
+    ) -> None:
+        """Fetch finished orders within the specified time window (default: last hour)."""
+
+        now_ms = int(time.time() * 1000)
+        if end_time is None:
+            end_time = now_ms
+        if start_time is None:
+            start_time = end_time - 60 * 60 * 1000
+        if start_time >= end_time:
+            raise ValueError("start_time must be earlier than end_time")
+
+        params: dict[str, Any] = {
+            "ProductGroup": product_group,
+            "pageIndex": page_index,
+            "pageSize": page_size,
+            "startTime": start_time,
+            "endTime": end_time,
+        }
+        if instrument_id:
+            params["InstrumentID"] = instrument_id
+
+        await self.store.initialize(
+            self.client.get(
+                f"{self.front_api}/cfd/cff/v1/FinishOrder",
+                params=params,
+                headers=self._rest_headers,
+            )
+        )
+
+    async def place_order(
+        self,
+        symbol: str,
+        *,
+        direction: Literal["buy", "sell", "0", "1"],
+        volume: float,
+        price: float | None = None,
+        order_type: Literal["market", "limit_ioc", "limit_gtc"] = "market",
+        offset_flag: Literal["open", "close", "0", "1"] = "open",
+        exchange_id: str = "Exchange",
+        product_group: str = "SwapU",
+        order_proportion: str = "0.0000",
+        client_order_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Create an order using documented REST parameters."""
+
+        direction_code = self._normalize_direction(direction)
+        offset_code = self._normalize_offset(offset_flag)
+        price_type_code, order_type_code = self._resolve_order_type(order_type)
+
+        detail_entry = self._get_detail_entry(symbol)
+        volume_str = self._format_with_step(volume, detail_entry.get("step_size"))
+        price_str: str | None = None
+        if price_type_code == "0":
+            if price is None:
+                raise ValueError("price is required for limit orders")
+            price_str = self._format_with_step(price, detail_entry.get("tick_size"))
+
+        payload: dict[str, Any] = {
+            # "ProductGroup": product_group,
+            "InstrumentID": symbol,
+            "ExchangeID": exchange_id,
+            "Direction": direction_code,
+            "OffsetFlag": offset_code,
+            "OrderPriceType": price_type_code,
+            "OrderType": order_type_code,
+            "Volume": volume_str,
+            "orderProportion": order_proportion,
+        }
+
+        if price_type_code == "0":
+            payload["Price"] = price_str
+        elif price is not None:
+            logger.warning("Price is ignored for market orders")
+
+        # if client_order_id:
+        #     payload["LocalID"] = client_order_id
+        print(payload)
+        res = await self.client.post(
+            f"{self.front_api}/cfd/cff/v1/SendOrderInsert",
+            json=payload,
+            headers=self._rest_headers,
+        )
+        data = await res.json()
+        return self._ensure_ok("place_order", data)
+
+    async def cancel_order(
+        self,
+        order_sys_id: str,
+        *,
+        action_flag: str | int = "1",
+    ) -> dict[str, Any]:
+        """Cancel an order by OrderSysID."""
+
+        payload = {"OrderSysID": order_sys_id, "ActionFlag": str(action_flag)}
+        res = await self.client.post(
+            f"{self.front_api}/cfd/action/v1.0/SendOrderAction",
+            json=payload,
+            headers=self._rest_headers,
+        )
+        data = await res.json()
+        return self._ensure_ok("cancel_order", data)
+
+    @staticmethod
+    def _ensure_ok(operation: str, data: Any) -> dict[str, Any]:
+        if not isinstance(data, dict) or data.get("code") != 200:
+            raise RuntimeError(f"{operation} failed: {data}")
+        return data.get("data") or {}
+
+    @staticmethod
+    def _normalize_direction(direction: str) -> str:
+        mapping = {
+            "buy": "0",
+            "long": "0",
+            "sell": "1",
+            "short": "1",
+        }
+        return mapping.get(str(direction).lower(), str(direction))
+
+    @staticmethod
+    def _normalize_offset(offset: str) -> str:
+        mapping = {
+            "open": "0",
+            "close": "1",
+        }
+        return mapping.get(str(offset).lower(), str(offset))
+
+    @staticmethod
+    def _resolve_order_type(order_type: str) -> tuple[str, str]:
+        mapping = {
+            "market": ("4", "1"),
+            "limit_ioc": ("0", "1"),
+            "limit_gtc": ("0", "0"),
+        }
+        try:
+            return mapping[str(order_type).lower()]
+        except KeyError as exc:  # pragma: no cover - guard
+            raise ValueError(f"Unsupported order_type: {order_type}") from exc
+
 
     async def sub_orderbook(self, symbols: list[str], limit: int | None = None) -> None:
         """订阅指定交易对的订单簿（遵循 LBank 协议）。
@@ -107,4 +350,4 @@ class Lbank:
             batch = send_jsons[i:i+5]
             await asyncio.gather(*(sub(send_json) for send_json in batch))
             if i + 5 < len(send_jsons):
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(0.1)

hyperquant/broker/models/edgex.py

@@ -235,6 +235,22 @@ class Ticker(DataStore):
             else:
                 self._update([item])
 
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        entries = data.get("data") or []
+
+        if not isinstance(entries, list):
+            entries = [entries]
+
+        items = []
+        for entry in entries:
+            item = self._format(entry)
+            if item:
+                items.append(item)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
     def _format(self, entry: dict[str, Any]) -> dict[str, Any] | None:
         contract_id = entry.get("contractId")
         if contract_id is None:
@@ -966,6 +982,8 @@ class EdgexDataStore(DataStoreCollection):
                 self.position._onresponse(data)
             elif res.url.path == "/api/v1/private/order/getActiveOrderPage":
                 self.orders._onresponse(data)
+            elif res.url.path == "/api/v1/public/quote/getTicker":
+                self.ticker._onresponse(data)
 
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
         # print(msg)

hyperquant/broker/models/lbank.py

@@ -121,12 +121,247 @@ class Detail(DataStore):
         self._insert(items)
 
 
+class Orders(DataStore):
+    """Active order snapshots fetched via the REST order query."""
+
+    _KEYS = ["order_id"]
+
+    _ORDER_STATUS_MAP = {
+        "1": "filled",
+        "2": "filled",
+        "4": "open",
+        "5": "partially_filled",
+        "6": "canceled",
+    }
+
+    _DIRECTION_MAP = {
+        "0": "buy",
+        "1": "sell",
+    }
+
+    _OFFSET_FLAG_MAP = {
+        "0": "open",
+        "1": "close",
+    }
+
+    def _transform(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        if not entry:
+            return None
+
+        order_id = entry.get("OrderSysID") or entry.get("orderSysID")
+        if not order_id:
+            return None
+
+        direction = self._DIRECTION_MAP.get(str(entry.get("Direction")), str(entry.get("Direction")))
+        offset_flag = self._OFFSET_FLAG_MAP.get(
+            str(entry.get("OffsetFlag")), str(entry.get("OffsetFlag"))
+        )
+
+        order_price_type = str(entry.get("OrderPriceType")) if entry.get("OrderPriceType") is not None else None
+        order_type = str(entry.get("OrderType")) if entry.get("OrderType") is not None else None
+
+        if order_price_type == "4":
+            order_kind = "market"
+        elif order_type == "1":
+            order_kind = "limit_fak"
+        else:
+            order_kind = "limit"
+
+        status_code = str(entry.get("OrderStatus")) if entry.get("OrderStatus") is not None else None
+        status = self._ORDER_STATUS_MAP.get(status_code, status_code)
+
+        client_order_id = (
+            entry.get("LocalID")
+            or entry.get("localID")
+            or entry.get("LocalId")
+            or entry.get("localId")
+        )
+
+        return {
+            "order_id": order_id,
+            "client_order_id": client_order_id,
+            "symbol": entry.get("InstrumentID"),
+            "side": direction,
+            "offset": offset_flag,
+            "order_type": order_kind,
+            "price": entry.get("Price"),
+            "quantity": entry.get("Volume"),
+            "filled": entry.get("VolumeTraded"),
+            "remaining": entry.get("VolumeRemain"),
+            "status": status,
+            "status_code": status_code,
+            "position_id": entry.get("PositionID"),
+            "leverage": entry.get("Leverage"),
+            "frozen_margin": entry.get("FrozenMargin"),
+            "frozen_fee": entry.get("FrozenFee"),
+            "insert_time": entry.get("InsertTime"),
+            "update_time": entry.get("UpdateTime"),
+        }
+
+    @staticmethod
+    def _extract_rows(data: dict[str, Any] | None) -> list[dict[str, Any]]:
+        if not data:
+            return []
+        payload = data.get("data") if isinstance(data, dict) else None
+        if isinstance(payload, dict):
+            rows = payload.get("data")
+            if isinstance(rows, list):
+                return rows
+        if isinstance(payload, list):  # pragma: no cover - defensive path
+            return payload
+        return []
+
+    def _onresponse(self, data: dict[str, Any] | None) -> None:
+        rows = self._extract_rows(data)
+        if not rows:
+            self._clear()
+            return
+
+        items: list[dict[str, Any]] = []
+        for row in rows:
+            transformed = self._transform(row)
+            if transformed:
+                items.append(transformed)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+class OrderFinish(Orders):
+    """Finished order snapshots fetched from the historical REST endpoint."""
+
+    def _onresponse(self, data: dict[str, Any] | None) -> None:
+        rows: list[dict[str, Any]] = []
+        if isinstance(data, dict):
+            payload = data.get("data") or {}
+            if isinstance(payload, dict):
+                list_payload = payload.get("list") or {}
+                if isinstance(list_payload, dict):
+                    rows = list_payload.get("resultList") or []
+
+        if not rows:
+            self._clear()
+            return
+
+        items: list[dict[str, Any]] = []
+        for row in rows:
+            transformed = self._transform(row)
+            if transformed:
+                items.append(transformed)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+class Position(DataStore):
+    """Open position snapshots fetched from the REST position endpoint."""
+
+    _KEYS = ["position_id"]
+
+    _POS_DIRECTION_MAP = {
+        "1": "net",
+        "2": "long",
+        "3": "short",
+    }
+
+    def _transform(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        if not entry:
+            return None
+        position_id = entry.get("PositionID")
+        if not position_id:
+            return None
+
+        direction_code = str(entry.get("PosiDirection")) if entry.get("PosiDirection") is not None else None
+        side = self._POS_DIRECTION_MAP.get(direction_code, direction_code)
+
+        return {
+            "position_id": position_id,
+            "symbol": entry.get("InstrumentID"),
+            "side": side,
+            "quantity": entry.get("Position"),
+            "available": entry.get("AvailableUse"),
+            "avg_price": entry.get("OpenPrice"),
+            "entry_price": entry.get("OpenPrice"),
+            "leverage": entry.get("Leverage"),
+            "liquidation_price": entry.get("estimateLiquidationPrice") or entry.get("FORCECLOSEPRICE"),
+            "margin_used": entry.get("UseMargin"),
+            "unrealized_pnl": entry.get("PositionFee"),
+            "realized_pnl": entry.get("CloseProfit"),
+            "update_time": entry.get("UpdateTime"),
+            "insert_time": entry.get("InsertTime"),
+        }
+
+    def _onresponse(self, data: dict[str, Any] | None) -> None:
+        rows = Orders._extract_rows(data)  # reuse helper for nested payload
+        if not rows:
+            self._clear()
+            return
+
+        items: list[dict[str, Any]] = []
+        for row in rows:
+            transformed = self._transform(row)
+            if transformed:
+                items.append(transformed)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+class Balance(DataStore):
+    """Account balance snapshot derived from sendQryAll endpoint."""
+
+    _KEYS = ["asset"]
+
+    def _init(self) -> None:
+        self._asset: str | None = None
+
+    def set_asset(self, asset: str | None) -> None:
+        self._asset = asset
+
+    def _transform(self, payload: dict[str, Any]) -> dict[str, Any] | None:
+        if not payload:
+            return None
+        asset_balance = payload.get("assetBalance") or {}
+        if not asset_balance:
+            return None
+
+        asset = payload.get("asset") or asset_balance.get("currency") or self._asset or "USDT"
+
+        return {
+            "asset": asset,
+            "balance": asset_balance.get("balance"),
+            "available": asset_balance.get("available"),
+            "real_available": asset_balance.get("realAvailable"),
+            "frozen_margin": asset_balance.get("frozenMargin"),
+            "frozen_fee": asset_balance.get("frozenFee"),
+            "total_close_profit": asset_balance.get("totalCloseProfit"),
+            "cross_margin": asset_balance.get("crossMargin"),
+        }
+
+    def _onresponse(self, data: dict[str, Any] | None) -> None:
+        payload: dict[str, Any] = {}
+        if isinstance(data, dict):
+            payload = data.get("data") or {}
+
+        item = self._transform(payload)
+        self._clear()
+        if item:
+            self._insert([item])
+
+
 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._create("orders", datastore_class=Orders)
+        self._create("order_finish", datastore_class=OrderFinish)
+        self._create("position", datastore_class=Position)
+        self._create("balance", datastore_class=Balance)
         self._channel_to_symbol: dict[str, str] = {}
 
     @property
@@ -185,6 +420,104 @@ class LbankDataStore(DataStoreCollection):
         """
         return self._get("detail")
 
+    @property
+    def orders(self) -> Orders:
+        """
+        活跃订单数据流。
+
+        此属性表示通过 REST 接口获取的当前活跃订单快照，包括已开仓订单、部分成交订单等状态。
+
+        Data structure:
+            [
+                {
+                    "order_id": <系统订单ID>,
+                    "client_order_id": <用户自定义订单ID>,
+                    "symbol": <合约ID>,
+                    "side": "buy" 或 "sell",
+                    "offset": "open" 或 "close",
+                    "order_type": "limit" / "market" / "limit_fak",
+                    "price": <下单价格>,
+                    "quantity": <下单数量>,
+                    "filled": <已成交数量>,
+                    "remaining": <剩余数量>,
+                    "status": <订单状态>,
+                    "status_code": <原始状态码>,
+                    "position_id": <关联仓位ID>,
+                    "leverage": <杠杆倍数>,
+                    "frozen_margin": <冻结保证金>,
+                    "frozen_fee": <冻结手续费>,
+                    "insert_time": <下单时间>,
+                    "update_time": <更新时间>
+                },
+                ...
+            ]
+
+        通过本属性可以跟踪当前活跃订单状态，便于订单管理和风控。
+        """
+        return self._get("orders")
+
+    @property
+    def order_finish(self) -> OrderFinish:
+        """历史已完成订单数据流，与 ``orders`` 字段保持兼容。"""
+        return self._get("order_finish")
+
+    @property
+    def position(self) -> Position:
+        """
+        持仓数据流。
+
+        此属性表示通过 REST 接口获取的当前持仓快照，包括多头、空头或净持仓等方向信息。
+
+        Data structure:
+            [
+                {
+                    "position_id": <仓位ID>,
+                    "symbol": <合约ID>,
+                    "side": "long" / "short" / "net",
+                    "quantity": <持仓数量>,
+                    "available": <可用数量>,
+                    "avg_price": <持仓均价>,
+                    "entry_price": <开仓均价>,
+                    "leverage": <杠杆倍数>,
+                    "liquidation_price": <预估强平价>,
+                    "margin_used": <已用保证金>,
+                    "unrealized_pnl": <未实现盈亏>,
+                    "realized_pnl": <已实现盈亏>,
+                    "update_time": <更新时间>,
+                    "insert_time": <插入时间>
+                },
+                ...
+            ]
+
+        通过本属性可以跟踪账户当前仓位状态，便于盈亏分析和风控。
+        """
+        return self._get("position")
+
+    @property
+    def balance(self) -> Balance:
+        """
+        账户余额数据流。
+
+        此属性表示通过 REST 接口获取的账户资产快照，包括余额、可用余额、保证金等信息。
+
+        Data structure:
+            [
+                {
+                    "asset": <资产币种>,
+                    "balance": <总余额>,
+                    "available": <可用余额>,
+                    "real_available": <实际可用余额>,
+                    "frozen_margin": <冻结保证金>,
+                    "frozen_fee": <冻结手续费>,
+                    "total_close_profit": <累计平仓收益>,
+                    "cross_margin": <全仓保证金>
+                }
+            ]
+
+        通过本属性可以跟踪账户余额与资金情况，便于资金管理和风险控制。
+        """
+        return self._get("balance")
+
 
     def register_book_channel(self, channel_id: str, symbol: str, *, raw_symbol: str | None = None) -> None:
         if channel_id is not None:
@@ -197,8 +530,17 @@ class LbankDataStore(DataStoreCollection):
         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)
+            if res.url.path == "/cfd/query/v1.0/Order":
+                self.orders._onresponse(data)
+            if res.url.path == "/cfd/query/v1.0/Position":
+                self.position._onresponse(data)
+            if res.url.path == "/cfd/agg/v1/sendQryAll":
+                self.balance._onresponse(data)
+            if res.url.path == "/cfd/cff/v1/FinishOrder":
+                self.order_finish._onresponse(data)
 
 
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:

{hyperquant-0.66.dist-info → hyperquant-0.68.dist-info}/METADATA

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

@@ -4,24 +4,24 @@ hyperquant/db.py,sha256=i2TjkCbmH4Uxo7UTDvOYBfy973gLcGexdzuT_YcSeIE,6678
 hyperquant/draw.py,sha256=up_lQ3pHeVLoNOyh9vPjgNwjD0M-6_IetSGviQUgjhY,54624
 hyperquant/logkit.py,sha256=nUo7nx5eONvK39GOhWwS41zNRL756P2J7-5xGzwXnTY,8462
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
-hyperquant/broker/auth.py,sha256=PgWw6eFGQtVbbA_JcJkK71L4JckinO8h2B0FrEV5G-U,6516
-hyperquant/broker/edgex.py,sha256=7oUY3HJUR87eSnkRFMEh1ttZCZkeAB_CkQF4Rodoevs,17645
+hyperquant/broker/auth.py,sha256=Wst7mTBuUS2BQ5hZd0a8FNNs5Uc01ac9WzJpseTuyAY,7673
+hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
-hyperquant/broker/lbank.py,sha256=kuxRfZylGZK3LRMzQJcB3w_nOXWM9-si65EwDsj0DnY,3325
+hyperquant/broker/lbank.py,sha256=7o0xaCuUuIGDUX93-1tnWBH39QGohHpqpL-KFa2OiJc,11662
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
 hyperquant/broker/ws.py,sha256=9Zu5JSLj-ylYEVmFmRwvZDDnVYKwb37cLHfZzA0AZGc,2200
 hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQJKcmyk,95785
 hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb84D8,8296
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
 hyperquant/broker/lib/util.py,sha256=u02kGb-7LMCi32UNLeKoPaZBZ2LBEjx72KRkaKX0yQg,275
-hyperquant/broker/models/edgex.py,sha256=ba9ogBprp3uGPgYprjBJoVcVWUBbmZ_l2hYCIGQCRpA,33449
+hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
-hyperquant/broker/models/lbank.py,sha256=ArYBHHF9p66rNXs9fn41W2asa5mK-mqgplajCHr51YA,7106
+hyperquant/broker/models/lbank.py,sha256=ZCD1dOUMyWPT8lKDj6C6LcHEof2d0JN384McURzLA-s,18868
 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.66.dist-info/METADATA,sha256=GVJWSwmMpQU_6dpHiOreOSExsvq4e3Pg34_QUHh_Y9U,4317
-hyperquant-0.66.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.66.dist-info/RECORD,,
+hyperquant-0.68.dist-info/METADATA,sha256=-5HFGYBVdzJALnWhh4AFh62i_3cPqw_CGs5wF3XXjEk,4317
+hyperquant-0.68.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.68.dist-info/RECORD,,