hyperquant 0.74__tar.gz → 0.76__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.74
+Version: 0.76
 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.74 → hyperquant-0.76}/pyproject.toml

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

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

@@ -223,7 +223,31 @@ class Lbank:
         page_index: int = 1,
         page_size: int = 20,
     ) -> dict[str, Any]:
-        """Aggregate trade executions to summarize overall order statistics."""
+        """
+        返回值示例:
+
+        .. 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")
@@ -440,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.74 → hyperquant-0.76}/src/hyperquant/broker/models/lbank.py

@@ -274,10 +274,14 @@ class Position(DataStore):
         bus_id = entry.get("BusinessNo")
         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)
-
+        
+        q = float(entry.get("Position", 0))
+        side = "net"
+        if q > 0:
+            side = "long"
+        elif q < 0:
+            side = "short"
+        
         return {
             "position_id": position_id,
             "bus_id": bus_id,

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

@@ -148,44 +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,
-) -> Union[dict, None]:
+    poll_interval: float = 0.5
+) :
+    
     """
-    由于 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"
-            } 
+    返回
+    {'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,
@@ -196,90 +169,72 @@ async def order_sync_polling(
     )
     
     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")
-        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
+    position_id = resp.get("positionID")
+    if not position_id:
+        raise RuntimeError(f"place_order 返回缺少 position_id: {resp}")
+    
+    trade_resp = None
+
+    if 'volumeRemain' in resp and float(resp['volumeRemain']) == 0 and float(resp.get('turnover', 0)) != 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'),
+        }
+
+    if 'ioc' in norm_type:
+        return {
+            "order_id": order_id,
+            "trade_count": 0
+        }
+
+    async def _poll_orders(timeout_sec: float) -> dict | None:
+        nonlocal trade_resp
         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")
+                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:
-        polled_position = await _poll_orders(window_sec, allow_symbol_fallback=False)
-        if polled_position:
-            return polled_position
+        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):
+        for _attempt in range(3):
+            try:
+                await broker.cancel_order(order_id)
                 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
+            except Exception as e:
+                if '不存在' in str(e):
+                    break
+                else:
+                    print(f'撤单失败, 重试 {_attempt+1}/3: {e}')
+        
+        try:
+            await _poll_orders(window_sec)
+        except TimeoutError:
+            pass
 
-    # 超过宽限期仍没有仓位变更，尝试最后一次使用 symbol 兜底
-    return await _refresh_position(allow_symbol_fallback=True)
+    return trade_resp
 
 
 async def test_order_sync_polling():
@@ -288,27 +243,42 @@ async def test_order_sync_polling():
             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
+            # bid0 = bid0 - 0.01
+            bid0 = bid0 + 1
+            # bid0 = bid0 - 1
             print(bid0)
 
-            result = await order_sync_polling(
+            snapshot = await order_sync_polling(
                 lb,
                 symbol="SOLUSDT",
                 direction="buy",
-                order_type="limit_GTC",
+                order_type="market",
                 price=bid0,
                 volume=0.03,
                 window_sec=3.0,
                 grace_sec=1,
                 poll_interval=1
             )
-            print(result)
+
+            position_id = snapshot.get("position_id")
+            if not position_id:
+                print('没有 position_id')
+
+            position = None
+            for _ in range(5):
+                await lb.update("position")
+                position = lb.store.position.get({"position_id": position_id})
+                if position:
+                    break
+                await asyncio.sleep(0.1)
+
+            print(position)
 
 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")
+            res = await lb.query_order("1000633284579483")
             print(res)
 
 if __name__ == "__main__":
-    asyncio.run(test_order_sync_polling())
+    asyncio.run(test_update())

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

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