hyperquant 0.72__tar.gz → 0.74__tar.gz

{hyperquant-0.72 → hyperquant-0.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.72
+Version: 0.74
 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.72 → hyperquant-0.74}/apis.json

@@ -7,8 +7,10 @@
     "78Uke-bPB57YoRzAwY7SkWyPQFeKkPuWVQakC0k9rSI",
     "3MB7nAnnNPTxAnwdbjDPew-02b746d6a832346a46a97faf054b2909c1a0b58a35e04c3504923a99a5503c1c"
   ],
-  "lbank": ["617a2d77b4cd4dfbbaa2094c17017bdb"],
-  "bitget": [
+  "lbank": [
+    "925a645e03c84c8e96b96008e98b75f7"
+  ],
+  "bitget":[
     "bg_03e0445d9282f248d22842cfe6f30192",
     "67ec894753d75fec12332881278420863a960ec39c8f5acf1de88aa1da926854",
     "huainian0408"

{hyperquant-0.72 → hyperquant-0.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "0.72"
+version = "0.74"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-0.72 → hyperquant-0.74}/src/hyperquant/broker/bitget.py

@@ -206,7 +206,7 @@ class Bitget:
         submsg = {"op": "subscribe", "args": []}
         for symbol in symbols:
             submsg["args"].append(
-                {"instType": "SPOT", "channel": channel, "instId": symbol}
+                {"instType": "USDT-FUTURES", "channel": channel, "instId": symbol}
             )
 
         self.client.ws_connect(

{hyperquant-0.72 → hyperquant-0.74}/src/hyperquant/broker/lbank.py

@@ -136,6 +136,138 @@ class Lbank:
 
         await self.store.initialize(*requests)
 
+    async def query_trade(
+        self,
+        order_id: str | None = None,
+        *,
+        product_group: str = "SwapU",
+        page_index: int = 1,
+        page_size: int = 20,
+    ) -> list[dict[str, Any]]:
+        """Fetch trade executions linked to a given OrderSysID.
+
+        Example response payload::
+
+            [
+                {
+                    "TradeUnitID": "e1b03fb1-6849-464f-a",
+                    "ProductGroup": "SwapU",
+                    "CloseProfit": 0,
+                    "BusinessNo": 1001770339345505,
+                    "TradeID": "1000162046503720",
+                    "PositionID": "1000632926272299",
+                    "DeriveSource": "0",
+                    "OrderID": "",
+                    "Direction": "0",
+                    "InstrumentID": "SOLUSDT",
+                    "OffsetFlag": "0",
+                    "Remark": "def",
+                    "DdlnTime": "0",
+                    "UseMargin": 0.054213,
+                    "Currency": "USDT",
+                    "Turnover": 5.4213,
+                    "SettlementGroup": "SwapU",
+                    "Leverage": 100,
+                    "OrderSysID": "1000632948114584",
+                    "ExchangeID": "Exchange",
+                    "AccountID": "e1b03fb1-6849-464f-a986-94b9a6e625e6",
+                    "TradeTime": 1760161085,
+                    "Fee": 0.00325278,
+                    "OrderPrice": 180.89,
+                    "InsertTime": 1760161085,
+                    "MemberID": "e1b03fb1-6849-464f-a986-94b9a6e625e6",
+                    "MatchRole": "1",
+                    "ClearCurrency": "USDT",
+                    "Price": 180.71,
+                    "Volume": 0.03,
+                    "OpenPrice": 182.94,
+                    "MasterAccountID": "",
+                    "PriceCurrency": "USDT",
+                    "FeeCurrency": "USDT"
+                    }
+            ]
+        """
+
+        if not order_id:
+            raise ValueError("order_id is required to query order executions")
+
+        params = {
+            "ProductGroup": product_group,
+            "OrderSysID": order_id,
+            "pageIndex": page_index,
+            "pageSize": page_size,
+        }
+
+        res = await self.client.get(
+            f"{self.front_api}/cfd/query/v1.0/Trade",
+            params=params,
+            headers=self._rest_headers,
+        )
+        data = await res.json()
+        payload = self._ensure_ok("query_trade", data)
+
+        if isinstance(payload, dict):
+            rows = payload.get("data")
+            if isinstance(rows, list):
+                return rows
+        elif isinstance(payload, list):  # pragma: no cover - defensive fallback
+            return payload
+
+        return []
+
+    async def query_order(
+        self,
+        order_id: str | None = None,
+        *,
+        product_group: str = "SwapU",
+        page_index: int = 1,
+        page_size: int = 20,
+    ) -> dict[str, Any]:
+        """Aggregate trade executions to summarize overall order statistics."""
+
+        if not order_id:
+            raise ValueError("order_id is required to query order statistics")
+
+        trades = await self.query_trade(
+            order_id,
+            product_group=product_group,
+            page_index=page_index,
+            page_size=page_size,
+        )
+
+        if not trades:
+            return {
+                "order_id": order_id,
+                "trade_count": 0,
+            }
+
+        def _to_float(value: Any) -> float:
+            try:
+                return float(value)
+            except (TypeError, ValueError):
+                return 0.0
+
+        total_volume = sum(_to_float(trade.get("Volume")) for trade in trades)
+        total_turnover = sum(_to_float(trade.get("Turnover")) for trade in trades)
+        total_fee = sum(_to_float(trade.get("Fee")) for trade in trades)
+
+        avg_price = total_turnover / total_volume if total_volume else None
+        last_trade = trades[-1]
+
+        return {
+            "order_id": order_id,
+            "instrument_id": last_trade.get("InstrumentID"),
+            "position_id": last_trade.get("PositionID"),
+            "direction": last_trade.get("Direction"),
+            "offset_flag": last_trade.get("OffsetFlag"),
+            "trade_time": last_trade.get("TradeTime"),
+            "avg_price": avg_price,
+            "volume": total_volume,
+            "turnover": total_turnover,
+            "fee": total_fee,
+            "trade_count": len(trades),
+        }
+
     def _resolve_instrument(self) -> str | None:
         detail_entries = self.store.detail.find()
         if detail_entries:
@@ -212,7 +344,71 @@ class Lbank:
         order_proportion: str = "0.0000",
         client_order_id: str | None = None,
     ) -> dict[str, Any]:
-        """Create an order using documented REST parameters."""
+        """Create an order using documented REST parameters.
+        
+        返回示例:
+
+        .. code:: json
+
+            {
+                "offsetFlag": "5",
+                "orderType": "1",
+                "reserveMode": "0",
+                "fee": "0.0066042",
+                "frozenFee": "0",
+                "ddlnTime": "0",
+                "userID": "lbank_exchange_user",
+                "masterAccountID": "",
+                "exchangeID": "Exchange",
+                "accountID": "e1b03fb1-6849-464f-a986-94b9a6e625e6",
+                "orderSysID": "1000633129818889",
+                "volumeRemain": "0",
+                "price": "183.36",
+                "businessValue": "1760183423813",
+                "frozenMargin": "0",
+                "instrumentID": "SOLUSDT",
+                "posiDirection": "2",
+                "volumeMode": "1",
+                "volume": "0.06",
+                "insertTime": "1760183423",
+                "copyMemberID": "",
+                "position": "0.06",
+                "tradePrice": "183.45",
+                "leverage": "100",
+                "businessResult": "",
+                "availableUse": "0",
+                "orderStatus": "1",
+                "openPrice": "182.94",
+                "frozenMoney": "0",
+                "remark": "def",
+                "reserveUse": "0",
+                "sessionNo": "41",
+                "isCrossMargin": "1",
+                "closeProfit": "0.0306",
+                "businessNo": "1001770756852986", # 订单有成交会并入仓位 businessNo
+                "relatedOrderSysID": "",
+                "positionID": "1000632926272299",
+                "mockResp": false,
+                "deriveSource": "0",
+                "copyOrderID": "",
+                "currency": "USDT",
+                "turnover": "11.007",
+                "frontNo": "-68",
+                "direction": "1",
+                "orderPriceType": "4",
+                "volumeCancled": "0",
+                "updateTime": "1760183423",
+                "localID": "1000633129818889",
+                "volumeTraded": "0.06",
+                "appid": "WEB",
+                "tradeUnitID": "e1b03fb1-6849-464f-a",
+                "businessType": "P",
+                "memberID": "e1b03fb1-6849-464f-a986-94b9a6e625e6",
+                "timeCondition": "0",
+                "copyProfit": "0"
+            }
+
+        """
 
         direction_code = self._normalize_direction(direction)
         offset_code = self._normalize_offset(offset_flag)

{hyperquant-0.72 → hyperquant-0.74}/src/hyperquant/broker/models/bitget.py

@@ -286,3 +286,74 @@ class BitgetDataStore(BitgetV2DataStore):
             ]
         """
         return self._get("book")
+    
+    @property
+    def account(self) -> DataStore:
+        """
+        _KEYS = ["instType", "marginCoin"]
+
+        Data Structure:
+
+        .. code:: json
+
+           [
+                {
+                    "marginCoin": "USDT",
+                    "frozen": "0.00000000",
+                    "available": "13.98545761",
+                    "maxOpenPosAvailable": "13.98545761",
+                    "maxTransferOut": "13.98545761",
+                    "equity": "13.98545761",
+                    "usdtEquity": "13.985457617660",
+                    "crossedRiskRate": "0",
+                    "unrealizedPL": "0.000000000000",
+                    "unionTotalMargin": "100",
+                    "unionAvailable": "20",
+                    "unionMm": "15",
+                    "assetMode": "union"
+                }
+            ]
+        """
+        return self._get("account")
+
+    @property
+    def position(self) -> DataStore:
+        """
+        _KEYS = ["instType", "instId", "posId"]
+
+        Data Structure:
+
+        .. code:: json
+
+           [
+                {
+                    "posId": "1",
+                    "instId": "ETHUSDT",
+                    "marginCoin": "USDT",
+                    "marginSize": "9.5",
+                    "marginMode": "crossed",
+                    "holdSide": "short",
+                    "posMode": "hedge_mode",
+                    "total": "0.1",
+                    "available": "0.1",
+                    "frozen": "0",
+                    "openPriceAvg": "1900",
+                    "leverage": 20,
+                    "achievedProfits": "0",
+                    "unrealizedPL": "0",
+                    "unrealizedPLR": "0",
+                    "liquidationPrice": "5788.108475905242",
+                    "keepMarginRate": "0.005",
+                    "marginRate": "0.004416374196",
+                    "cTime": "1695649246169",
+                    "breakEvenPrice": "24778.97",
+                    "totalFee": "1.45",
+                    "deductedFee": "0.388",
+                    "markPrice": "2500",
+                    "assetMode": "union",
+                    "uTime": "1695711602568",
+                    "autoMargin": "off"
+                }
+            ]
+        """
+        return self._get("position")

{hyperquant-0.72 → hyperquant-0.74}/src/hyperquant/broker/models/lbank.py

@@ -271,6 +271,7 @@ class Position(DataStore):
         if not entry:
             return None
         position_id = entry.get("PositionID")
+        bus_id = entry.get("BusinessNo")
         if not position_id:
             return None
 
@@ -279,6 +280,7 @@ class Position(DataStore):
 
         return {
             "position_id": position_id,
+            "bus_id": bus_id,
             "symbol": entry.get("InstrumentID"),
             "side": side,
             "quantity": entry.get("Position"),
@@ -473,6 +475,7 @@ class LbankDataStore(DataStoreCollection):
             [
                 {
                     "position_id": <仓位ID>,
+                    "bus_id": <订单ID覆盖>,
                     "symbol": <合约ID>,
                     "side": "long" / "short" / "net",
                     "quantity": <持仓数量>,

{hyperquant-0.72 → hyperquant-0.74}/tests/test_lbank.py

@@ -2,9 +2,10 @@ import asyncio
 import json
 import time
 import zlib
-from typing import Literal
+from typing import Literal, Union
 
 from aiohttp import ClientWebSocketResponse
+from aiohttp.client_exceptions import ContentTypeError
 import pybotters
 
 
@@ -103,28 +104,33 @@ async def test_broker_subbook():
 async def test_update():
     async with pybotters.Client(apis='./apis.json') as client:
         async with Lbank(client) as lb:
-            # await lb.update('position')
-            # print(lb.store.position.find())
+            await lb.update('position')
+            print(lb.store.position.find())
             # await lb.update('balance')
             # print(lb.store.balance.find())
             # await lb.update('detail')
             # print(lb.store.detail.find())
-            await lb.update('orders')
+            # await lb.update('orders')
+            # await lb.update('orders_finish')
   
-            print(lb.store.order_finish.find())
+            # print(lb.store.order_finish.find({
+            #     'order_id': '1000632478428573'
+            # }))
 
 async def test_place():
     async with pybotters.Client(apis='./apis.json') as client:
         async with Lbank(client) as lb:
             order = await lb.place_order(
-                "0GUSDT",
+                "SOLUSDT",
                 direction="buy",
                 order_type='limit_gtc',
-                price=3.5342,
-                volume=4.176760504552669,
+                price=182,
+                volume=0.03,
             )
             print(order)
 
+
+
 async def test_cancel():
     async with pybotters.Client(apis='./apis.json') as client:
         async with Lbank(client) as lb:
@@ -132,36 +138,6 @@ async def test_cancel():
             print(res)
 
 
-async def wait_order_state_poll(
-    broker: Lbank,
-    order_id: str,
-    symbol: str,
-    seconds: float,
-    poll_interval: float = 0.5,
-) -> dict:
-    """轮询 REST 接口，等待订单进入终态。"""
-
-    async with asyncio.timeout(seconds):
-        last_snapshot: dict | None = None
-        while True:
-            await broker.update("orders")
-            snapshot = broker.store.orders.get({"order_id": order_id})
-            if snapshot:
-                last_snapshot = snapshot
-                status = snapshot.get("status")
-                if status in {"filled", "canceled"}:
-                    return snapshot
-            else:
-                await broker.update_finish_order(instrument_id=symbol)
-                finished = broker.store.order_finish.get({"order_id": order_id})
-                if finished:
-                    return finished
-            await asyncio.sleep(poll_interval)
-
-    # asyncio.timeout will raise TimeoutError; this return is defensive
-    return last_snapshot or {}
-
-
 async def order_sync_polling(
     broker: Lbank,
     *,
@@ -173,12 +149,32 @@ async def order_sync_polling(
     window_sec: float = 5.0,
     grace_sec: float = 5.0,
     poll_interval: float = 0.5,
-) -> dict:
+) -> Union[dict, None]:
     """
-    由于 LBank 暂无订单推送，这里通过 ``update`` 轮询同步订单状态。
-    
-    - window_sec: 主轮询窗口，订单若持续存在则触发撤单流程。
-    - grace_sec: 撤单后的额外等待窗口。
+    由于 LBank 暂无订单推送，这里通过 REST ``orders`` 与 ``position`` 查询实现订单同步，可在不同状态下返回仓位快照。
+
+    - window_sec: 主轮询窗口，订单若持续存在则触发撤单流程；
+    - grace_sec: 撤单后的额外等待窗口；
+    - 返回值示例：
+        .. code:: json
+
+            {
+                "position_id": "1000633222380983",
+                "bus_id": "1001770970175249",
+                "symbol": "SOLUSDT",
+                "side": "long",
+                "quantity": "0.06",
+                "available": "0.0",
+                "avg_price": "183.62",
+                "entry_price": "183.62",
+                "leverage": "100.0",
+                "liquidation_price": "0",
+                "margin_used": "0.110175",
+                "unrealized_pnl": "0.0",
+                "realized_pnl": "0.0",
+                "update_time": "1760195121",
+                "insert_time": "1758806193"
+            } 
     """
 
     norm_type = order_type.lower()
@@ -198,6 +194,7 @@ async def order_sync_polling(
         price=price,
         volume=volume,
     )
+    
     latency = int(time.time() * 1000) - started
     print(f"下单延迟 {latency} ms")
 
@@ -210,46 +207,108 @@ async def order_sync_polling(
     if not order_id:
         raise RuntimeError(f"place_order 返回缺少 order_id: {resp}")
 
+    position_id = (
+        resp.get("PositionID")
+        or resp.get("positionID")
+        or resp.get("positionId")
+    )
+
+    async def _refresh_position(*, allow_symbol_fallback: bool) -> dict | None:
+        try:
+            await broker.update("position")
+        except ContentTypeError:
+            await asyncio.sleep(poll_interval)
+            return None
+        if position_id:
+            pos = broker.store.position.get({"position_id": position_id})
+            if pos and pos.get("avg_price") is not None:
+                return pos
+        if allow_symbol_fallback:
+            candidates = broker.store.position.find({"symbol": symbol}) or []
+            if candidates:
+                pos = candidates[0]
+                if pos and pos.get("avg_price") is not None:
+                    return pos
+        return None
+
+    async def _poll_orders(timeout_sec: float, *, allow_symbol_fallback: bool) -> dict | None:
+        nonlocal position_id
+        order_seen = False
+        async with asyncio.timeout(timeout_sec):
+            while True:
+                try:
+                    await broker.update("orders")
+                except ContentTypeError:
+                    await asyncio.sleep(poll_interval)
+                    continue
+                snapshot = broker.store.orders.get({"order_id": order_id})
+                if snapshot is None:
+                    if not order_seen and not allow_symbol_fallback:
+                        await asyncio.sleep(poll_interval)
+                        continue
+                    pos_snapshot = await _refresh_position(allow_symbol_fallback=allow_symbol_fallback)
+                    if pos_snapshot is not None:
+                        return pos_snapshot
+                    await asyncio.sleep(poll_interval)
+                    continue
+                order_seen = True
+                position_id = position_id or snapshot.get("position_id")
+                await asyncio.sleep(poll_interval)
+
     try:
-        return await wait_order_state_poll(
-            broker,
-            order_id,
-            symbol,
-            window_sec,
-            poll_interval=poll_interval,
-        )
+        polled_position = await _poll_orders(window_sec, allow_symbol_fallback=False)
+        if polled_position:
+            return polled_position
     except TimeoutError:
+        pass
+
+    for _attempt in range(3):
         try:
             await broker.cancel_order(order_id)
-        except Exception as exc:
-            print(f"cancel failed: {exc}")
-        try:
-            return await wait_order_state_poll(
-                broker,
-                order_id,
-                symbol,
-                grace_sec,
-                poll_interval=poll_interval,
-            )
-        except TimeoutError:
-            return {"order_id": order_id, "symbol": symbol, "state": "timeout"}
+            break
+        except Exception as e:
+            if '不存在' in str(e):
+                break
+            else:
+                print(f'撤单失败, 重试 {_attempt+1}/3: {e}')
+    try:
+        polled_position = await _poll_orders(grace_sec, allow_symbol_fallback=True)
+        if polled_position:
+            return polled_position
+    except TimeoutError:
+        pass
+
+    # 超过宽限期仍没有仓位变更，尝试最后一次使用 symbol 兜底
+    return await _refresh_position(allow_symbol_fallback=True)
 
 
 async def test_order_sync_polling():
     async with pybotters.Client(apis="./apis.json") as client:
         async with Lbank(client) as lb:
+            await lb.sub_orderbook(["SOLUSDT"], limit=1)
+            await lb.store.book.wait()
+            bid0 = float(lb.store.book.find({"s": "SOLUSDT", 'S': 'b'})[0]['p'])
+            bid0 = bid0 - 0.03
+            print(bid0)
+
             result = await order_sync_polling(
                 lb,
                 symbol="SOLUSDT",
                 direction="buy",
-                order_type="limit_gtc",
-                price=200.1,
+                order_type="limit_GTC",
+                price=bid0,
                 volume=0.03,
                 window_sec=3.0,
-                grace_sec=3.0,
-                poll_interval=1.0,
+                grace_sec=1,
+                poll_interval=1
             )
             print(result)
 
+async def test_query_order():
+    async with pybotters.Client(apis='./apis.json') as client:
+        async with Lbank(client) as lb:
+            res = await lb.query_order("1000633129818889")
+            print(res)
+
 if __name__ == "__main__":
     asyncio.run(test_order_sync_polling())

{hyperquant-0.72 → hyperquant-0.74}/uv.lock

@@ -530,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "0.71"
+version = "0.73"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },