hyperquant 1.2__tar.gz → 1.21__tar.gz

{hyperquant-1.2 → hyperquant-1.21}/PKG-INFO

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

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

{hyperquant-1.2 → hyperquant-1.21}/src/hyperquant/broker/bitmart.py

@@ -30,6 +30,7 @@ class Bitmart:
         self.private_api = "https://derivatives.bitmart.com"
         self.forward_api = f'{self.private_api}/gw-api/contract-tiger/forward'
         self.ws_url = ws_url or "wss://contract-ws-v2.bitmart.com/v1/ifcontract/realTime"
+        self.api_ws_url = "wss://openapi-ws-v2.bitmart.com/api?protocol=1.1"
 
         self.account_index = account_index
         self.apis = apis
@@ -281,6 +282,7 @@ class Bitmart:
         *,
         depth: str = "Depth",
         depth_limit: int | None = None,
+        use_api_ws: bool = True,
     ) -> pybotters.ws.WebSocketApp:
         """Subscribe order book channel(s)."""
 
@@ -289,37 +291,55 @@ class Bitmart:
 
         if not symbols:
             raise ValueError("symbols must not be empty")
-
-        missing = [sym for sym in symbols if self.get_contract_id(sym) is None]
-        if missing:
-            await self.update("detail")
-            still_missing = [sym for sym in missing if self.get_contract_id(sym) is None]
-            if still_missing:
-                raise ValueError(f"Unknown symbols: {', '.join(still_missing)}")
-
         if depth_limit is not None:
             self.store.book.limit = depth_limit
+        if not use_api_ws:
+            missing = [sym for sym in symbols if self.get_contract_id(sym) is None]
+            if missing:
+                await self.update("detail")
+                still_missing = [sym for sym in missing if self.get_contract_id(sym) is None]
+                if still_missing:
+                    raise ValueError(f"Unknown symbols: {', '.join(still_missing)}")
 
-        channels: list[str] = []
-        for symbol in symbols:
-            contract_id = self.get_contract_id(symbol)
-            if contract_id is None:
-                continue
-            self.store.book.id_to_symbol[str(contract_id)] = symbol
-            channels.append(f"{depth}:{contract_id}")
 
-        if not channels:
-            raise ValueError("No channels resolved for subscription")
 
-        payload = {"action": "subscribe", "args": channels}
-        # print(payload)
+            channels: list[str] = []
+            for symbol in symbols:
+                contract_id = self.get_contract_id(symbol)
+                if contract_id is None:
+                    continue
+                self.store.book.id_to_symbol[str(contract_id)] = symbol
+                channels.append(f"{depth}:{contract_id}")
+
+            if not channels:
+                raise ValueError("No channels resolved for subscription")
+
+            payload = {"action": "subscribe", "args": channels}
+            # print(payload)
+
+            ws_app = self.client.ws_connect(
+                self.api_ws_url,
+                send_json=payload,
+                hdlr_json=self.store.onmessage,
+            )
+        else:
+            channels: list[str] = []
+            for symbol in symbols:
+                channels.append(f"futures/depthAll5:{symbol}@100ms")
+
+            if not channels:
+                raise ValueError("No channels resolved for subscription")
+
+            payload = {"action": "subscribe", "args": channels}
+            # print(payload)
+
+            ws_app = self.client.ws_connect(
+                self.api_ws_url,
+                send_json=payload,
+                hdlr_json=self.store.onmessage,
+                autoping=False,
+            )
 
-        ws_app = self.client.ws_connect(
-            self.ws_url,
-            send_json=payload,
-            hdlr_json=self.store.onmessage,
-            autoping=False,
-        )
         await ws_app._event.wait()
         return ws_app
   

{hyperquant-1.2 → hyperquant-1.21}/src/hyperquant/broker/models/bitmart.py

@@ -62,6 +62,7 @@ class Book(DataStore):
     def _on_message(self, msg: dict[str, Any]) -> None:
         data = msg.get("data")
         group = msg.get("group")
+        ms_t = msg.get("ms_t")
         if not isinstance(data, dict) or not isinstance(group, str):
             return
 
@@ -94,7 +95,57 @@ class Book(DataStore):
             for entry in depths
         ])
 
-        self._last_update = time.time()
+        self._last_update = ms_t
+    
+    def _on_message_api(self, msg: dict[str, Any]) -> None:
+        # {
+        #     "data": {
+        #         "symbol": "BTCUSDT",
+        #         "asks": [
+        #             {
+        #                 "price": "70294.4",
+        #                 "vol": "455"
+        #             }
+        #         ],
+        #         "bids": [
+        #             {
+        #                 "price": "70293.9",
+        #                 "vol": "1856"
+        #             }
+        #         ],
+        #         "ms_t": 1730399750402
+        #     },
+        #     "group": "futures/depthAll20:BTCUSDT@200ms"
+        # }
+        data = msg.get("data")
+        if not isinstance(data, dict):
+            return
+        symbol = data.get("symbol")
+        asks = data.get("asks") or []
+        bids = data.get("bids") or []
+        if self.limit:
+            asks = asks[: self.limit]
+            bids = bids[: self.limit]
+            
+        self._find_and_delete({'s': symbol})
+        self._update([
+            self._make_entry(
+                symbol,
+                "a",
+                entry.get("price", '0'),
+                entry.get("vol", '0'),
+            )
+            for entry in asks
+        ])
+        self._update([
+            self._make_entry(
+                symbol,
+                "b",
+                entry.get("price", '0'),
+                entry.get("vol", '0'),
+            )
+            for entry in bids
+        ])
 
     def sorted(self, query: Item | None = None, limit: int | None = None) -> dict[str, list[Item]]:
         return self._sorted(
@@ -278,8 +329,12 @@ class BitmartDataStore(DataStoreCollection):
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
         if isinstance(msg, dict):
             group = msg.get("group")
-            if isinstance(group, str) and group.startswith("Depth"):
-                self.book._on_message(msg)
+
+            if isinstance(group, str):
+                if group.startswith("futures/depth"):
+                    self.book._on_message_api(msg)
+                if group.startswith("Depth"):
+                    self.book._on_message(msg)
 
     @property
     def book(self) -> Book:

{hyperquant-1.2 → hyperquant-1.21}/tests/test_bitmart.py

@@ -10,9 +10,8 @@ from hyperquant.logkit import get_logger
 from hyperquant.broker.bitmart import Bitmart
 
 
-
 async def test_update():
-    async with pybotters.Client(apis='./apis.json') as client:
+    async with pybotters.Client(apis="./apis.json") as client:
         async with Bitmart(client=client) as broker:
             # print(broker.store.detail.find()[0])
             # await broker.update('balances')
@@ -23,14 +22,14 @@ async def test_update():
             # await broker.update('history_orders')
             # print(broker.store.orders.find())
             # print(broker.store.orders.get({'order_id':3000237069605967}))
-            await broker.update('positions')
+            await broker.update("positions")
             print(broker.store.positions.find())
 
             # print(broker.store.detail.find({'name':'PUMPUSDT'}))
 
 
 async def test_place():
-    async with pybotters.Client(apis='./apis.json') as client:
+    async with pybotters.Client(apis="./apis.json") as client:
         async with Bitmart(client=client) as broker:
             # [2025-10-31 17:34:15] 🔵 准备建仓: VIRTUAL_USDT entry=short qty=20.498804 lag_px=1.4635 lead=binance
             # [2025-11-01 01:33:22] 🔵 准备建仓: PUMP_USDT entry=long qty=18872.375560 lag_px=0.004239 lead=binance
@@ -38,17 +37,19 @@ async def test_place():
             for i in range(2):
                 start = time.time()
                 oid = await broker.place_order(
-                    symbol='PUMPUSDT',
-                    side='sell',
-                    category='limit',
+                    symbol="PUMPUSDT",
+                    side="sell",
+                    category="limit",
                     price=0.004239,
                     qty=18872.375560,
-                    mode='ioc',
-                    leverage=40
+                    mode="ioc",
+                    leverage=40,
                     # qty_contract=1
                 )
 
-                print(f"Placed order ID: {oid}, 下单毫秒数: {(time.time() - start)*1000:.2f} ms")
+                print(
+                    f"Placed order ID: {oid}, 下单毫秒数: {(time.time() - start)*1000:.2f} ms"
+                )
 
                 # resp = await broker.cancel_order(
                 #     symbol='VIRTUALUSDT',
@@ -57,6 +58,7 @@ async def test_place():
 
                 # print(f"Cancel response: {resp}")
 
+
 @dataclass
 class OrderSyncResult:
     position: dict[str, Any]
@@ -90,7 +92,7 @@ async def order_sync_polling(
         if logger:
             logger.warning(f"Order placement failed: {e}")
         return OrderSyncResult(position={}, order={})
-    
+
     async def sync() -> OrderSyncResult:
         await broker.update("history_orders")
         await broker.update("positions")
@@ -104,7 +106,6 @@ async def order_sync_polling(
                     position = positions[0]
         return OrderSyncResult(position=position or {}, order=order or {})
 
-
     for attempt in range(cancel_retry):
         await asyncio.sleep(1)
         await broker.update("history_orders")
@@ -124,16 +125,17 @@ async def order_sync_polling(
 
     return OrderSyncResult(position={}, order={})
 
+
 async def test_sub_book():
     async with pybotters.Client() as client:
         async with Bitmart(client=client) as broker:
             broker.store.book.limit = 1
-            await broker.sub_orderbook(["TRXUSDT", 'XRPUSDT', 'DOTUSDT'])
+            await broker.sub_orderbook(["ASRUSDT"])
             while True:
                 # await broker.store.book.wait()
                 # print(broker.store.book.find())
-                asks = broker.store.book.find({"S": "a", 's': 'TRXUSDT'})
-                bids = broker.store.book.find({"S": "b", 's': 'TRXUSDT'})
+                asks = broker.store.book.find({"S": "a", "s": "ASRUSDT"})
+                bids = broker.store.book.find({"S": "b", "s": "ASRUSDT"})
                 # 订单薄format化输出
                 print("Asks:")
                 for ask in asks:
@@ -144,20 +146,21 @@ async def test_sub_book():
                 print("-" * 30)
                 await asyncio.sleep(1)
 
-
             # with broker.store.book.watch() as stream:
             #     async for change in stream:
             #         print(change)
 
+
 async def test_auto_refresh():
-    async with pybotters.Client(apis='./apis.json') as client:
-        async with Bitmart(client=client, apis='./apis.json') as broker:
+    async with pybotters.Client(apis="./apis.json") as client:
+        async with Bitmart(client=client, apis="./apis.json") as broker:
             await broker.auto_refresh(0, test=True)
             await asyncio.sleep(2)
 
+
 async def test_sync_place():
     logger = get_logger("test_sync_place")
-    async with pybotters.Client(apis='./apis.json') as client:
+    async with pybotters.Client(apis="./apis.json") as client:
         async with Bitmart(client=client) as broker:
             # place_task = broker.place_order(
             #     symbol='VIRTUALUSDT',
@@ -170,10 +173,10 @@ async def test_sync_place():
 
             place_task = broker.place_order(  # type: ignore[attr-defined]
                 symbol="VELODROMEUSDT",
-                side='sell',
+                side="sell",
                 qty_contract=int(round(1.000000)),
                 price=0.040645,
-                category='market'
+                category="market",
             )
             result = await order_sync_polling(
                 broker,
@@ -185,13 +188,111 @@ async def test_sync_place():
             )
             logger.info(f"Order Sync Result: {result}")
 
+
 async def test_set_leverage():
-    async with pybotters.Client(apis='./apis.json') as client:
+    async with pybotters.Client(apis="./apis.json") as client:
         async with Bitmart(client=client) as broker:
-            await broker.bind_leverage(symbol='BTCUSDT', leverage=10)
+            await broker.bind_leverage(symbol="BTCUSDT", leverage=10)
             # get current leverage
-            lev_info = await broker.get_leverage(symbol='BTCUSDT')
+            lev_info = await broker.get_leverage(symbol="BTCUSDT")
             print(lev_info)
 
+
+async def test_close_all():
+    async with pybotters.Client(apis="./apis.json") as client:
+        async with Bitmart(client=client) as broker:
+            await broker.place_order(
+                symbol="PORT3USDT",
+                side="buy",
+                qty_contract=5,
+                category="market",
+                price=0,
+            )
+
+
+async def test_sub_book_compare():
+    async with pybotters.Client() as client:
+        async with Bitmart(client=client) as broker:
+            mst_t = None
+            a_counter = 0
+            a_last_time = None
+            a_total_interval = 0.0
+
+            def book_handler(msg: dict, ws):
+                nonlocal mst_t
+                nonlocal a_counter
+                nonlocal a_last_time
+                nonlocal a_total_interval
+                a_counter += 1
+                now = time.time() * 1000  # ms
+                if a_last_time is not None:
+                    a_total_interval += (now - a_last_time)
+                a_last_time = now
+                mst_t = msg.get("data", {}).get("ms_t", None)
+
+            b_counter = 0
+            b_last_time = None
+            b_total_interval = 0.0
+
+            def book_handler_2(msg: dict, ws):
+                nonlocal mst_t
+                nonlocal b_counter
+                nonlocal b_last_time
+                nonlocal b_total_interval
+                way = msg.get("data", {}).get("way", None)
+                if way == 1:
+                    b_counter += 1
+                    now = time.time() * 1000  # ms
+                    if b_last_time is not None:
+                        b_total_interval += (now - b_last_time)
+                    b_last_time = now
+                mst_t = msg.get("data", {}).get("ms_t", None)
+
+                
+
+            await client.ws_connect(
+                url="wss://openapi-ws-v2.bitmart.com/api?protocol=1.1",
+                send_json=[
+                    {"action": "subscribe", "args": ["futures/depth5:BTCUSDT@100ms"]}
+                ],
+                hdlr_json=book_handler,
+            )
+
+
+            await client.ws_connect(
+                url="wss://contract-ws-v2.bitmart.com/v1/ifcontract/realTime",
+                send_json=[
+                    {
+                        "action": "subscribe",
+                        "args": [
+                            "Depth:1",
+                        ],
+                    }
+                ],
+                hdlr_json=book_handler_2,
+            )
+
+            await asyncio.sleep(10)
+            print(f"Handler A received {a_counter} messages.")
+            if a_counter > 1:
+                print(f"Handler A average interval: {a_total_interval / (a_counter - 1):.2f} ms")
+            else:
+                print("Handler A average interval: N/A")
+
+            print(f"Handler B received {b_counter} messages.")
+            if b_counter > 1:
+                print(f"Handler B average interval: {b_total_interval / (b_counter - 1):.2f} ms")
+            else:
+                print("Handler B average interval: N/A")
+
+async def test_sub_book_api():
+    async with pybotters.Client() as client:
+        async with Bitmart(client=client) as broker:
+            await broker.sub_orderbook(['TRXUSDT', 'DOTUSDT'], depth_limit=1, use_api_ws=True)
+            await broker.store.book.wait()
+            while True:
+                await broker.store.book.wait()
+                print(broker.store.book.find())
+
 if __name__ == "__main__":
-    asyncio.run(test_set_leverage())
+    asyncio.run(test_sub_book_api())

{hyperquant-1.2 → hyperquant-1.21}/uv.lock

@@ -921,7 +921,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.1"
+version = "1.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },