hyperquant 0.73__tar.gz → 0.75__tar.gz

{hyperquant-0.73 → hyperquant-0.75}/PKG-INFO

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

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

{hyperquant-0.73 → hyperquant-0.75}/pyproject.toml

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

{hyperquant-0.73 → hyperquant-0.75}/src/hyperquant/broker/lbank.py

@@ -136,6 +136,162 @@ 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]:
+        """
+        返回值示例:
+
+        .. code:: json
+
+            {
+                "order_id": "1000632478428573",
+                "instrument_id": "SOLUSDT",
+                "position_id": "1000632478428573",
+                "direction": "0",
+                "offset_flag": "0",
+                "trade_time": 1760123456,
+                "avg_price": 182.5,
+                "volume": 0.03,
+                "turnover": 5.475,
+                "fee": 0.003285,
+                "trade_count": 1
+            }
+        
+        如果没有订单成交返回
+            {
+                "order_id": "1000632478428573",
+                "trade_count": 0
+            }
+        """
+
+        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 +368,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)
@@ -244,9 +464,7 @@ class Lbank:
             # logger.warning("Price is ignored for market orders")
             pass
 
-        # 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,

{hyperquant-0.73 → hyperquant-0.75}/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.73 → hyperquant-0.75}/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,
     *,
@@ -172,24 +148,17 @@ async def order_sync_polling(
     volume: float | None = None,
     window_sec: float = 5.0,
     grace_sec: float = 5.0,
-    poll_interval: float = 0.5,
-) -> dict:
-    """
-    由于 LBank 暂无订单推送，这里通过 ``update`` 轮询同步订单状态。
+    poll_interval: float = 0.5
+) :
     
-    - window_sec: 主轮询窗口，订单若持续存在则触发撤单流程。
-    - grace_sec: 撤单后的额外等待窗口。
+    """
+    返回
+    {'order_id': '1000633291976722', 'instrument_id': 'SOLUSDT', 'position_id': '1000633291830781', 'direction': '1', 'offset_flag': '0', 'trade_time': 1760203736, 'avg_price': 183.95000000000002, 'volume': 0.03, 'turnover': 5.5185, 'fee': 0.0033111, 'trade_count': 1}
+    或者
+    {'order_id': '1000633291976722', 'trade_count': 0}
     """
 
     norm_type = order_type.lower()
-    if norm_type not in {"market", "limit_gtc", "limit_ioc"}:
-        raise ValueError(f"unsupported order_type: {order_type}")
-
-    if norm_type != "market" and price is None:
-        raise ValueError("price is required for limit orders")
-    if volume is None:
-        raise ValueError("volume is required for LBank orders")
-
     started = int(time.time() * 1000)
     resp = await broker.place_order(
         symbol,
@@ -198,58 +167,98 @@ async def order_sync_polling(
         price=price,
         volume=volume,
     )
+    
     latency = int(time.time() * 1000) - started
-    print(f"下单延迟 {latency} ms")
 
-    order_id = (
-        resp.get("orderSysID")
-        or resp.get("OrderSysID")
-        or resp.get("order_id")
-        or resp.get("orderId")
-    )
+    order_id = resp.get("orderSysID")
+    # print(f"下单延迟 {latency} ms, 订单号: {order_id}")
+
     if not order_id:
         raise RuntimeError(f"place_order 返回缺少 order_id: {resp}")
 
+
+    position_id = resp.get("positionID")
+    if not position_id:
+        raise RuntimeError(f"place_order 返回缺少 position_id: {resp}")
+    
+    if 'volumeRemain' in resp and float(resp['volumeRemain']) == 0:
+        return {
+            "order_id": order_id,
+            "trade_count": 1,
+            "volume": volume,
+            "avg_price": float(resp.get('openPrice', 0)),
+            "turnover": float(resp.get('turnover', 0)),
+            "fee": float(resp.get('fee', 0)),
+            "position_id": position_id,
+            "direction": direction,
+            "offset_flag": resp.get('offsetFlag', '0'),
+            "trade_time": resp.get('updateTime'),
+        }
+
+    trade_resp = None
+
+    async def _poll_orders(timeout_sec: float) -> dict | None:
+        nonlocal trade_resp
+        async with asyncio.timeout(timeout_sec):
+            while True:
+                trade_resp = await broker.query_order(order_id)
+                traded_volume = float(trade_resp.get("volume", 0))
+                if traded_volume == volume:
+                    return
+                await asyncio.sleep(poll_interval)
+
     try:
-        return await wait_order_state_poll(
-            broker,
-            order_id,
-            symbol,
-            window_sec,
-            poll_interval=poll_interval,
-        )
+        await _poll_orders(window_sec)
+    
     except TimeoutError:
+        pass
+
+        for _attempt in range(3):
+            try:
+                await broker.cancel_order(order_id)
+                break
+            except Exception as e:
+                if '不存在' in str(e):
+                    break
+                else:
+                    print(f'撤单失败, 重试 {_attempt+1}/3: {e}')
+        
         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,
-            )
+            await _poll_orders(window_sec)
         except TimeoutError:
-            return {"order_id": order_id, "symbol": symbol, "state": "timeout"}
+            pass
+
+    return trade_resp
 
 
 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.01
+            # bid0 = bid0 - 1
+            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("1000633284579483")
+            print(res)
+
 if __name__ == "__main__":
     asyncio.run(test_order_sync_polling())

{hyperquant-0.73 → hyperquant-0.75}/uv.lock

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