hyperquant 0.43__tar.gz → 0.45__tar.gz

{hyperquant-0.43 → hyperquant-0.45}/PKG-INFO

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

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

{hyperquant-0.43 → hyperquant-0.45}/src/hyperquant/broker/models/ourbit.py

@@ -697,69 +697,85 @@ class SpotBook(DataStore):
         # super().__init__()
         self._time: int | None = None
         self.limit = 1
+        self.loss = True
+        self.version = None
 
     def _onresponse(self, data: dict[str, Any]):
+        data = data.get("data")
+        symbol = data.get("symbol")
+        book_data = data.get("data")
+        asks = book_data.get("asks", [])
+        bids = book_data.get("bids", [])
+        version = int(data.get("version", 0))
+
+        # 保存当前快照版本
+        self.version = version
+        
+        # 应用缓存的增量（只保留连续的部分）
+        items: list = self.find({"s": symbol})
+        items.sort(key=lambda x: x.get("fv", 0))  # 按 fromVersion 排序
 
-        top = data.get("data") or data.get("d") or data
-        symbol = (
-            top.get("s")
-            or top.get("symbol")
-            or (top.get("data") or {}).get("symbol")
-        )
-
-        inner = top.get("data") or top
-        asks = inner.get("asks") or []
-        bids = inner.get("bids") or []
-
-        items: list[Item] = []
-        if symbol:
-            # Snapshot semantics: rebuild entries for this symbol
-            self._find_and_delete({"s": symbol})
-
-        def extract_pq(level: Any) -> tuple[Any, Any] | None:
-            # Accept dict {"p": x, "q": y} or list/tuple [p, q, ...]
-            if isinstance(level, dict):
-                p = level.get("p")
-                q = level.get("q")
-                return (p, q)
-            if isinstance(level, (list, tuple)) and len(level) >= 2:
-                return (level[0], level[1])
-            return None
-
+        # 清空旧数据，插入快照
+        self._find_and_delete({"s": symbol})
+        
         for side, S in ((asks, "a"), (bids, "b")):
-            for level in side:
-                pq = extract_pq(level)
-                if not pq:
-                    continue
-                p, q = pq
-                if p is None or q is None:
-                    continue
-                try:
-                    if float(q) == 0.0:
-                        continue
-                except (TypeError, ValueError):
-                    continue
-                items.append({"s": symbol, "S": S, "p": p, "q": q})
+            for item in side:
+                self._insert([{"s": symbol, "S": S, "p": item["p"], "q": item["q"]}])
 
         if items:
-            self._insert(items)
-    
-        sort_data = self.sorted({'s': symbol}, self.limit)
-        asks = sort_data.get('a', [])
-        bids = sort_data.get('b', [])
-        self._find_and_delete({'s': symbol})
-        self._update(asks + bids)
-        
+            min_version = min(item.get("fv", 0) for item in items)
+            max_version = max(item.get("tv", 0) for item in items)
+            self.version = max_version
+
+            if not (min_version <= self.version <= max_version):
+                self.loss = True
+                logger.warning(f"SpotBook: Snapshot version {self.version} out of range ({min_version}, {max_version}) for symbol={symbol} (丢补丁)")
+                return
+
+            self.loss = False
+            for item in items:
+                fv, tv = item.get("fv", 0), item.get("tv", 0)
+                if self.version <= tv and self.version >= fv:
+                    self._insert([{ "s": symbol, "S": item["S"], "p": item["p"], "q": item["q"]}])
+        else:
+            self.loss = False
 
 
     def _on_message(self, msg: dict[str, Any]) -> None:
+
         ts = time.time() * 1000  # 预留时间戳（如需记录可用）
         data   = msg.get("d", {}) or {}
         symbol = msg.get("s")
-
+        fv = int(data.get("fromVersion"))
+        tv = int(data.get("toVersion"))
         asks: list = data.get("asks", []) or []
         bids: list = data.get("bids", []) or []
 
+        # 以下几张情况都会被认为正常
+        check_con = (
+            self.version is None or
+            fv <= self.version <= tv or
+            self.version + 1 == fv
+        )
+
+        if not check_con:
+            logger.warning(f"(丢补丁)  version:{self.version} fv:{fv} tv:{tv} msg:\n {msg}")
+            # self.loss = True # 暂时不这样做
+            return
+        
+        self.version = tv
+
+        if self.loss:
+            for item in asks:
+                self._insert(
+                    [{"s": symbol, "S": "a", "p": item["p"], "q": item["q"], "fv": fv, "tv": tv}]
+                )
+            for item in bids:
+                self._insert(
+                    [{"s": symbol, "S": "b", "p": item["p"], "q": item["q"], "fv": fv, "tv": tv}]
+                )
+            return
+
         to_delete, to_update = [], []
         for side, S in ((asks, "a"), (bids, "b")):
             for item in side:
@@ -777,7 +793,7 @@ class SpotBook(DataStore):
         self._find_and_delete({'s': symbol})
         self._update(asks + bids)
 
-        # print(f'处理耗时: {time.time()*1000 - ts:.2f} ms')
+        print(f'处理耗时: {time.time()*1000 - ts:.2f} ms')
 
     
 

{hyperquant-0.43 → hyperquant-0.45}/src/hyperquant/broker/ourbit.py

@@ -389,31 +389,20 @@ class OurbitSpot:
         Args:
             symbols: 交易对符号，可以是单个字符串或字符串列表
         """
+        import logging
+        logger = logging.getLogger("OurbitSpot")
+
         if isinstance(symbols, str):
             symbols = [symbols]
 
-        # 并发获取每个交易对的初始深度数据
-        tasks = [
-            self.client.fetch('GET', f"{self.api_url}/api/platform/spot/market/depth?symbol={symbol}")
-            for symbol in symbols
-        ]
-        
-        # 等待所有请求完成
-        responses = await asyncio.gather(*tasks)
-        
-        # 处理响应数据
-        for response in responses:
-            self.store.book._onresponse(response.data)
-
         # 构建订阅参数
         subscription_params = []
         for symbol in symbols:
             subscription_params.append(f"spot@public.increase.aggre.depth@{symbol}")
 
-
         # 一次sub20个，超过需要分开订阅
         for i in range(0, len(subscription_params), 20):
-            self.client.ws_connect(
+            wsapp = self.client.ws_connect(
                 'wss://www.ourbit.com/ws?platform=web',
                 send_json={
                     "method": "SUBSCRIPTION",
@@ -422,12 +411,38 @@ class OurbitSpot:
                 },
                 hdlr_json=self.store.onmessage
             )
+            await wsapp._event.wait()
+        
+        # await asyncio.sleep(2)  # 等待ws连接稳定
+
+        # 并发获取每个交易对的初始深度数据
+        tasks = [
+            self.client.fetch('GET', f"{self.api_url}/api/platform/spot/market/depth?symbol={symbol}")
+            for symbol in symbols
+        ]
+        
+        # 等待所有请求完成
+        responses = await asyncio.gather(*tasks)
+        
+        # 处理响应数据
+        for idx, response in enumerate(responses):
+            symbol = symbols[idx]
+            self.store.book._onresponse(response.data)
+            # Check if initialization failed (loss is False), retry if so
+            retry_count = 0
+            while self.store.book.loss is True:
+                logger.warning(f"Orderbook initialization failed for {symbol}, refetching depth snapshot (retry {retry_count+1})")
+                await asyncio.sleep(0.1)
+                response_retry = await self.client.fetch('GET', f"{self.api_url}/api/platform/spot/market/depth?symbol={symbol}")
+                self.store.book._onresponse(response_retry.data)
+                retry_count += 1
+
 
     async def place_order(
         self,
         symbol: str,
         side: Literal["buy", "sell"],
-        price: float,
+        price: float = None,
         quantity: float = None,
         order_type: Literal["market", "limit"] = "limit",
         usdt_amount: float = None
@@ -437,7 +452,7 @@ class OurbitSpot:
         Args:
             symbol: 交易对，如 "SOL_USDT"
             side: 买卖方向 "buy" 或 "sell"
-            price: 价格
+            price: 价格，市价单可为None
             quantity: 数量
             order_type: 订单类型 "market" 或 "limit"
             usdt_amount: USDT金额，如果指定则根据价格计算数量
@@ -445,74 +460,72 @@ class OurbitSpot:
         Returns:
             订单响应数据
         """
+        # 参数检查
+        if order_type == "limit" and price is None:
+            raise ValueError("Limit orders require a price")
+        if quantity is None and usdt_amount is None:
+            raise ValueError("Either quantity or usdt_amount must be specified")
+            
         # 解析交易对
-        currency, market = symbol.split("_")
-
-        detail = self.store.detail.get({
-            'name': currency
-        })
-
+        parts = symbol.split("_")
+        if len(parts) != 2:
+            raise ValueError(f"Invalid symbol format: {symbol}")
+            
+        currency, market = parts
+        
+        # 获取交易对详情
+        detail = self.store.detail.get({"name": currency})
         if not detail:
             raise ValueError(f"Unknown currency: {currency}")
-
-        price_scale = detail.get('price_scale')
-        quantity_scale = detail.get('quantity_scale')
-
-        use_quantity = True if quantity is not None else False
-
-        # 如果指定了USDT金额，重新计算数量
-        if usdt_amount is not None:
-            if side == "buy":
-                quantity = usdt_amount / price
-            else:
-                # 卖出时usdt_amount表示要卖出的币种价值
-                quantity = usdt_amount / price
-        
-        # 格式化价格和数量
-        if price_scale is not None:
-            price = round(price, price_scale)
-        
-        if quantity_scale is not None:
-            quantity = round(quantity, quantity_scale)
+            
+        price_scale = detail.get("price_scale")
+        quantity_scale = detail.get("quantity_scale")
         
         # 构建请求数据
         data = {
             "currency": currency,
             "market": market,
-            "tradeType": side.upper(),
-            "quantity": str(quantity),
+            "tradeType": side.upper()
         }
         
+        # 处理市价单和限价单的不同参数
         if order_type == "limit":
             data["orderType"] = "LIMIT_ORDER"
-            data["price"] = str(price)
+            data["price"] = str(round(price, price_scale) if price_scale is not None else price)
+            
+            # 计算并设置数量
+            if quantity is None and usdt_amount is not None and price:
+                quantity = usdt_amount / price
+                
+            if quantity_scale is not None:
+                quantity = round(quantity, quantity_scale)
+            data["quantity"] = str(quantity)
+                
         elif order_type == "market":
             data["orderType"] = "MARKET_ORDER"
-            data["price"] = price
-            # 删除quantity, 市价只支持amount
-            if not use_quantity:
-                del data["quantity"]
+            
+            # 市价单可以使用数量或金额，但不能同时使用
+            if usdt_amount is not None:
                 data["amount"] = str(usdt_amount)
-
-        # print(data)
-        if order_type == 'market':
-            url = f'{self.api_url}/api/platform/spot/v4/order/place'
-        elif order_type == 'limit':
-            url = f'{self.api_url}/api/platform/spot/order/place'
+            else:
+                if quantity_scale is not None:
+                    quantity = round(quantity, quantity_scale)
+                data["quantity"] = str(quantity)
+                
+            if price:
+                data["price"] = str(price)
         
-        res = await self.client.fetch(
-            "POST", 
-            url, 
-            json=data
-        )
+        # 确定API端点
+        url = f'{self.api_url}/api/platform/spot/{"v4/order/place" if order_type == "market" else "order/place"}'
+        
+        # 发送请求
+        res = await self.client.fetch("POST", url, json=data)
         
         # 处理响应
-        match res.data:
-            case {"msg": 'success'}:
-                return res.data["data"]
-            case _:
-                raise Exception(f"Failed to place order: {res.data}")
-            
+        if res.data.get("msg") == "success":
+            return res.data["data"]
+        raise Exception(f"Failed to place order: {res.data}")
+    
     async def cancel_orders(self, order_ids: list[str]):
 
         for order_id in order_ids:

{hyperquant-0.43 → hyperquant-0.45}/tmp.py

@@ -133,9 +133,24 @@ async def test_cancel_order():
         # await ob_spot.sub_personal()
         # await ob_spot.update('all')
 
-        oid = await ob_spot.place_order('SOL_USDT', 'buy',  order_type='limit', price=205, quantity=0.03 )
+        oid = await ob_spot.place_order('SOL_USDT', 'sell',  order_type='market', quantity=0.03 )
         print(oid)
-        await ob_spot.cancel_orders([oid])
+        # await ob_spot.cancel_orders([oid])
+
+
+async def test_orderbook():
+    async with pybotters.Client(apis={
+        "ourbit": [
+            "WEB3bf088f8b2f2fae07592fe1a6240e2d798100a9cb2a91f8fda1056b6865ab3ee"
+        ]
+    }) as client:
+        ob_spot = OurbitSpot(client)
+        await ob_spot.__aenter__()
+        await ob_spot.sub_orderbook(['XRP_USDT'])
+        while True:
+            await ob_spot.store.book.wait()
+            print(ob_spot.store.book.find())
+
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(test_orderbook())

{hyperquant-0.43 → hyperquant-0.45}/uv.lock

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