hyperquant 0.37__tar.gz → 0.39__tar.gz

{hyperquant-0.37 → hyperquant-0.39}/PKG-INFO

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

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

hyperquant-0.39/src/hyperquant/broker/auth.py

@@ -0,0 +1,88 @@
+import time
+import hashlib
+from typing import Any
+from aiohttp import ClientWebSocketResponse
+from multidict import CIMultiDict
+from yarl import URL
+import pybotters
+import json as pyjson
+from urllib.parse import urlencode
+
+
+def md5_hex(s: str) -> str:
+    return hashlib.md5(s.encode("utf-8")).hexdigest()
+
+
+# 🔑 Ourbit 的鉴权函数
+class Auth:
+    @staticmethod
+    def ourbit(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        data = kwargs.get("data") or {}
+        headers: CIMultiDict = kwargs["headers"]
+
+        # 从 session 里取 token
+        session = kwargs["session"]
+        token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
+
+        # 时间戳 & body
+        now_ms = int(time.time() * 1000)
+        raw_body_for_sign = (
+            data
+            if isinstance(data, str)
+            else pyjson.dumps(data, separators=(",", ":"), ensure_ascii=False)
+        )
+
+        # 签名
+        mid_hash = md5_hex(f"{token}{now_ms}")[7:]
+        final_hash = md5_hex(f"{now_ms}{raw_body_for_sign}{mid_hash}")
+
+        # 设置 headers
+        headers.update(
+            {
+                "Authorization": token,
+                "Language": "Chinese",
+                "language": "Chinese",
+                "Content-Type": "application/json",
+                "x-ourbit-sign": final_hash,
+                "x-ourbit-nonce": str(now_ms),
+            }
+        )
+
+        # 更新 kwargs.body，保证发出去的与签名一致
+        kwargs.update({"data": raw_body_for_sign})
+
+        return args
+
+    @staticmethod
+    def ourbit_spot(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        data = kwargs.get("data") or {}
+        headers: CIMultiDict = kwargs["headers"]
+
+        # 从 session 里取 token
+        session = kwargs["session"]
+        token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
+        cookie = f"uc_token={token}; u_id={token}; "
+        headers.update({"cookie": cookie})
+
+        # wss消息增加参数
+        # if headers.get("Upgrade") == "websocket":
+        #     args = (method, url)
+        #     # 拼接 token
+        #     q = dict(url.query)
+        #     q["token"] = token
+        #     url = url.with_query(q)
+
+
+        return args
+
+
+pybotters.auth.Hosts.items["futures.ourbit.com"] = pybotters.auth.Item(
+    "ourbit", Auth.ourbit
+)
+pybotters.auth.Hosts.items["www.ourbit.com"] = pybotters.auth.Item(
+    "ourbit", Auth.ourbit_spot
+)

{hyperquant-0.37 → hyperquant-0.39}/src/hyperquant/broker/models/ourbit.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from typing import TYPE_CHECKING, Any, Awaitable
 
 import aiohttp
@@ -29,7 +30,7 @@ class Book(DataStore):
 
     """
 
-    _KEYS = ["symbol", "side", "px"]
+    _KEYS = ["symbol", "side",  "i"]
 
     def _init(self) -> None:
         # super().__init__()
@@ -41,6 +42,10 @@ class Book(DataStore):
         data = msg.get("data", {})
         asks = data.get("asks", [])
         bids = data.get("bids", [])
+        # 提速 默认 5当前
+        asks = asks[:5]
+        bids = bids[:5]
+
         timestamp = data.get("ct")  # 使用服务器时间
 
         data_to_insert: list[Item] = []
@@ -50,7 +55,7 @@ class Book(DataStore):
 
         # 处理买卖盘数据
         for side_id, levels in (("B", bids), ("A", asks)):
-            for level in levels:
+            for i, level in enumerate(levels):
                 # level格式: [price, size, count]
                 if len(level) >= 3:
                     price, size, count = level[0:3]
@@ -61,6 +66,7 @@ class Book(DataStore):
                             "px": str(price),
                             "sz": str(size),
                             "count": count,
+                            "i": i
                         }
                     )
 
@@ -295,6 +301,8 @@ class Balance(DataStore):
         data: dict = msg.get("data", {})
         self._update([self._fmt(data)])
 
+
+
 class OurbitSwapDataStore(DataStoreCollection):
     """
     Ourbit DataStoreCollection
@@ -423,6 +431,7 @@ class OurbitSwapDataStore(DataStoreCollection):
                     "px": "110152.5",        # 价格
                     "sz": "53539",           # 数量
                     "count": 1               # 订单数量
+                    "i" 0                  # 价格档位索引
                 },
                 {
                     "symbol": "BTC_USDT",    # 交易对
@@ -430,6 +439,7 @@ class OurbitSwapDataStore(DataStoreCollection):
                     "px": "110152.4",        # 价格
                     "sz": "76311",           # 数量
                     "count": 1               # 订单数量
+                    "i" 0                  # 价格档位索引
                 }
             ]
         """
@@ -548,3 +558,496 @@ class OurbitSwapDataStore(DataStoreCollection):
             """
             return self._get("balance", Balance)
         return self._get("balance", Balance)
+
+# SpotBalance: 现货账户余额数据存储
+
+class SpotBalance(DataStore):
+    _KEYS = ["currency"]
+
+    def _fmt(self, balance: dict) -> dict:
+        return {
+            "currency": balance.get("currency"),
+            "available": balance.get("available"),
+            "frozen": balance.get("frozen"),
+            "amount": balance.get("amount"),
+            "avg_price": balance.get("avgPrice"),
+        }
+
+    def _fmt_ws(self, balance: dict) -> dict:
+        return {
+            "currency": balance.get("s"),
+            "available": balance.get("av"),
+            "frozen": balance.get("fr"),
+            "amount": balance.get("to"),
+            "avg_price": balance.get("ap"),
+        }
+
+    def _onresponse(self, data: dict[str, Any]):
+        balances = data.get("data", [])
+        items = [self._fmt(b) for b in balances]
+        if items:
+            self._clear()
+            self._insert(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("d", {})
+        item = self._fmt_ws(data)
+        self._update([item])
+
+
+# SpotOrders: 现货订单数据存储
+class SpotOrders(DataStore):
+    _KEYS = ["order_id"]
+
+
+    def _fmt(self, order: dict) -> dict:
+        state = order.get("state")
+        if state == 1 or state == 2:
+            state = "open"
+        elif state == 3:
+            state = "filled"
+        elif state == 4:
+            state = "canceled"
+
+        return {
+            "order_id": order.get("id"),
+            "symbol": order.get("symbol"),
+            "currency": order.get("currency"),
+            "market": order.get("market"),
+            "trade_type": order.get("tradeType"),
+            "order_type": order.get("orderType"),
+            "price": order.get("price"),
+            "quantity": order.get("quantity"),
+            "amount": order.get("amount"),
+            "deal_quantity": order.get("dealQuantity"),
+            "deal_amount": order.get("dealAmount"),
+            "avg_price": order.get("avgPrice"),
+            "state": order.get("state"),
+            "source": order.get("source"),
+            "fee": order.get("fee"),
+            "create_ts": order.get("createTime"),
+            "unique_id": order.get("uniqueId"),
+        }
+    
+
+
+    def _onresponse(self, data: dict[str, Any]):
+        orders = (data.get("data") or {}).get("resultList", [])
+        items = [self._fmt(order) for order in orders]
+        self._clear()
+        if items:
+            self._insert(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        d:dict = msg.get("d", {})
+
+        
+        item = {
+            "order_id": d.get("id"),
+            "symbol": msg.get("s") or d.get("symbol"),
+            "trade_type": d.get("tradeType"),
+            "order_type": d.get("orderType"),
+            "price": d.get("price"),
+            "quantity": d.get("quantity"),
+            "amount": d.get("amount"),
+            "remain_quantity": d.get("remainQ"),
+            "remain_amount": d.get("remainA"),
+            "state": d.get("status"),
+            "client_order_id": d.get("clientOrderId"),
+            "is_taker": d.get("isTaker"),
+            "create_ts": d.get("createTime"),
+            "source": d.get("internal"),
+        }
+
+        state = d.get("status")
+
+        if state == 2 or state == 1:
+            item["state"] = "open"
+            self._insert([item])
+        
+        elif state == 3:
+            item["state"] = "filled"
+
+            # 如果这三个字段存在追加
+            if d.get("singleDealId") and d.get("singleDealPrice") and d.get("singleDealQuantity"):
+                item.update({
+                    "unique_id": d.get("singleDealId"),
+                    "avg_price": d.get("singleDealPrice"),
+                    "deal_quantity": d.get("singleDealQuantity"),
+                })
+
+                self._update([item])
+                self._find_and_delete({  "order_id": d.get("id")  })
+        
+        elif state == 4:
+            item["state"] = "canceled"
+            self._update([item])
+            self._find_and_delete({  "order_id": d.get("id")  })
+
+
+
+class SpotBook(DataStore):
+    _KEYS = ["s", "S", 'p']
+
+    def _init(self) -> None:
+        # super().__init__()
+        self._time: int | None = None
+        self.limit = 1
+
+    def _onresponse(self, data: dict[str, Any]):
+
+        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
+
+        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})
+
+        if items:
+            self._insert(items)
+    
+        sort_data = self.sorted({'s': symbol}, self.limit)
+        asks = sort_data.get('a', [])
+        bids = sort_data.get('b', [])
+        self._clear()
+        self._update(asks + bids)
+        
+
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        ts = time.time() * 1000  # 预留时间戳（如需记录可用）
+        data   = msg.get("d", {}) or {}
+        symbol = msg.get("s")
+
+        asks: list = data.get("asks", []) or []
+        bids: list = data.get("bids", []) or []
+
+        to_delete, to_update = [], []
+        for side, S in ((asks, "a"), (bids, "b")):
+            for item in side:
+                if float(item["q"]) == 0.0:
+                    to_delete.append({"s": symbol, "S": S, "p": item["p"]})
+                else:
+                    to_update.append({"s": symbol, "S": S, "p": item["p"], "q": item["q"]})
+        
+        self._delete(to_delete)
+        self._insert(to_update)
+
+        sort_data = self.sorted({'s': symbol}, self.limit)
+        asks = sort_data.get('a', [])
+        bids = sort_data.get('b', [])
+        self._clear()
+        self._update(asks + bids)
+
+        # print(f'处理耗时: {time.time()*1000 - ts:.2f} ms')
+
+    
+
+    def sorted(
+        self, query: Item | None = None, limit: int | None = None
+    ) -> dict[str, list[Item]]:
+        return self._sorted(
+            item_key="S",
+            item_asc_key="a",
+            item_desc_key="b",
+            sort_key="p",
+            query=query,
+            limit=limit,
+        )
+
+    @property
+    def time(self) -> int | None:
+        """返回最后更新时间"""
+        return self._time
+
+
+
+class SpotTicker(DataStore):
+    _KEYS = ["symbol"]
+
+    def _fmt(self, t: dict[str, Any]) -> dict[str, Any]:
+        # 根据示例：
+        # { id: "...", sb: "WCT_USDT", r8: "0.0094", tzr: "0.0094", c: "0.3002", h: "0.3035", l: "0.292", o: "0.2974", q: "1217506.41", a: "363548.8205" }
+        return {
+            "id": t.get("id"),
+            "symbol": t.get("sb"),
+            "last_price": t.get("c"),
+            "open_price": t.get("o"),
+            "high_price": t.get("h"),
+            "low_price": t.get("l"),
+            "volume24": t.get("q"),
+            "amount24": t.get("a"),
+            "rise_fall_rate": t.get("r8") if t.get("r8") is not None else t.get("tzr"),
+        }
+
+    def _onresponse(self, data: dict[str, Any] | list[dict[str, Any]]):
+        # 支持 data 为:
+        # - 直接为 list[dict]
+        # - {"data": list[dict]}
+        # - {"d": list[dict]}
+        payload = data
+        if isinstance(data, dict):
+            payload = data.get("data") or data.get("d") or data
+        if not isinstance(payload, list):
+            payload = [payload]
+        items = [self._fmt(t) for t in payload if isinstance(t, dict)]
+        if not items:
+            return
+        self._clear()
+        self._insert(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        # 兼容 WS:
+        # { "c": "increase.tickers", "d": { ...ticker... } }
+        d = msg.get("d") or msg.get("data") or msg
+        if not isinstance(d, dict):
+            return
+        item = self._fmt(d)
+        if not item.get("symbol"):
+            return
+        # 覆盖式更新该 symbol
+        self._find_and_delete({"symbol": item["symbol"]})
+        self._insert([item])
+
+class SpotDetail(DataStore):
+    _KEYS = ["name"]
+
+    def _fmt(self, detail: dict) -> dict:
+        return {
+            "id": detail.get("id"),                    # 唯一ID
+            "name": detail.get("vn"),          # 虚拟币简称
+            "name_abbr": detail.get("vna"),    # 虚拟币全称
+            "final_name": detail.get("fn"),            # 法币符号/展示名
+            "sort": detail.get("srt"),                 # 排序字段
+            "status": detail.get("sts"),               # 状态 (1=可用, 0=不可用)
+            "type": detail.get("tp"),                  # 类型 (NEW=新币种)
+            "internal_id": detail.get("in"),           # 内部唯一流水号
+            "first_online_time": detail.get("fot"),    # 首次上线时间
+            "online_time": detail.get("ot"),           # 上线时间
+            "coin_partition": detail.get("cp"),        # 所属交易区分类
+            "price_scale": detail.get("ps"),           # 价格小数位数
+            "quantity_scale": detail.get("qs"),        # 数量小数位数
+            "contract_decimal_mode": detail.get("cdm"), # 合约精度模式
+            "contract_address": detail.get("ca"),      # 代币合约地址
+        }
+
+    def _onresponse(self, data: dict[str, Any]):
+        details = data.get("data", {}).get('USDT')
+        if not details:
+            return
+        
+        items = [self._fmt(detail) for detail in details]
+        self._clear()
+        self._insert(items)
+
+
+class OurbitSpotDataStore(DataStoreCollection):
+    """
+    Ourbit DataStoreCollection Spot
+    """
+    def _init(self) -> None:
+        self._create("book", datastore_class=SpotBook)
+        self._create("ticker", datastore_class=SpotTicker)
+        self._create("balance", datastore_class=SpotBalance)
+        self._create("order", datastore_class=SpotOrders)
+        self._create("detail", datastore_class=SpotDetail)
+
+    @property
+    def book(self) -> SpotBook:
+        """
+        获取现货订单簿
+        .. code:: json
+            [
+                {
+                    "s": "BTC_USDT",
+                    "S": "a",
+                    "p": "110152.5",
+                    "q": "53539"
+                }
+            ]
+
+        """
+        return self._get("book")
+    
+    @property
+    def ticker(self) -> SpotTicker:
+        """
+        获取现货 Ticker
+        .. code:: json
+            [
+                {
+                    "symbol": "WCT_USDT",
+                    "last_price": "0.3002",
+                    "open_price": "0.2974",
+                    "high_price": "0.3035",
+                    "low_price": "0.292",
+                    "volume24": "1217506.41",
+                    "amount24": "363548.8205",
+                    "rise_fall_rate": "0.0094",
+                    "id": "dc893d07ca8345008db4d874da726a15"
+                }
+            ]
+        """
+        return self._get("ticker")
+
+    @property
+    def balance(self) -> SpotBalance:
+        """
+        现货账户余额数据流
+
+        Data structure:
+
+        .. code:: python
+
+            [
+                {
+                    "currency": "USDT",       # 币种
+                    "available": "100.0",     # 可用余额
+                    "frozen": "0.0",          # 冻结余额
+                    "usdt_available": "100.0",# USDT 可用余额
+                    "usdt_frozen": "0.0",     # USDT 冻结余额
+                    "amount": "100.0",        # 总金额
+                    "avg_price": "1.0",       # 平均价格
+                    "last_price": "1.0",      # 最新价格
+                    "hidden_small": False,    # 是否隐藏小额资产
+                    "icon": ""                # 币种图标
+                }
+            ]
+        """
+        return self._get("balance", SpotBalance)
+    
+    @property
+    def detail(self) -> SpotDetail:
+        """
+        现货交易对详情数据流
+
+        Data structure:
+
+        .. code:: python
+
+            [
+                {
+                    "id": "3aada397655d44d69f4fc899b9c88531",        # 唯一ID
+                    "name": "USD1",                         # 虚拟币简称
+                    "name_abbr": "USD1",                    # 虚拟币全称
+                    "final_name": "USD1",                           # 法币符号/展示名
+                    "sort": 57,                                     # 排序字段
+                    "status": 1,                                    # 状态 (1=可用, 0=不可用)
+                    "type": "NEW",                                  # 类型 (NEW=新币种)
+                    "internal_id": "F20250508113754813fb3qX9NPxRoNUF", # 内部唯一流水号
+                    "first_online_time": 1746676200000,             # 首次上线时间
+                    "online_time": 1746676200000,                   # 上线时间
+                    "coin_partition": ["ob_trade_zone_defi"],       # 所属交易区分类
+                    "price_scale": 4,                               # 价格小数位数
+                    "quantity_scale": 2,                            # 数量小数位数
+                    "contract_decimal_mode": 1,                     # 合约精度模式
+                    "contract_address": "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d" # 代币合约地址
+                }
+            ]
+        """
+        return self._get("detail", SpotDetail)
+    
+    @property
+    def orders(self) -> SpotOrders:
+        """
+        现货订单数据流
+
+        Data structure:
+
+        .. code:: python
+
+            [
+                {
+                    "order_id": "123456",      # 订单ID
+                    "symbol": "BTC_USDT",      # 交易对
+                    "currency": "USDT",        # 币种
+                    "market": "BTC_USDT",      # 市场
+                    "trade_type": "buy",       # 交易类型
+                    "order_type": "limit",     # 订单类型
+                    "price": "11000.0",        # 委托价格
+                    "quantity": "0.01",        # 委托数量
+                    "amount": "110.0",         # 委托金额
+                    "deal_quantity": "0.01",   # 成交数量
+                    "deal_amount": "110.0",    # 成交金额
+                    "avg_price": "11000.0",    # 成交均价
+                    "state": "open",           # 订单状态
+                    "source": "api",           # 来源
+                    "fee": "0.01",             # 手续费
+                    "create_ts": 1625247600000,# 创建时间戳
+                    "unique_id": "abcdefg"     # 唯一标识
+                }
+            ]
+        """
+        return self._get("order", SpotOrders)
+    
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        channel = msg.get("c")
+        if 'msg' in msg:
+            if 'invalid' in msg['msg']:
+                logger.warning(f"WebSocket message invalid: {msg['msg']}")
+                return
+
+        if channel is None:
+            return
+        
+        if 'increase.aggre.depth' in channel:
+            self.book._on_message(msg)
+
+        if 'spot@private.orders' in channel:
+            self.orders._on_message(msg)
+        
+        if 'spot@private.balances' in channel:
+            self.balance._on_message(msg)
+
+        if 'ticker' in channel:
+            self.ticker._on_message(msg)
+
+    async def initialize(self, *aws: Awaitable[aiohttp.ClientResponse]) -> None:
+        """Initialize DataStore from HTTP response data."""
+        for f in asyncio.as_completed(aws):
+            res = await f
+            data = await res.json()
+            if res.url.path == "/api/platform/spot/market/depth":
+                self.book._onresponse(data)
+            if res.url.path == "/api/platform/spot/market/v2/tickers":
+                self.ticker._onresponse(data)
+            if res.url.path == "/api/assetbussiness/asset/spot/statistic":
+                self.balance._onresponse(data)
+            if res.url.path == "/api/platform/spot/order/current/orders/v2":
+                self.orders._onresponse(data)
+            if res.url.path == "/api/platform/spot/market/v2/symbols":
+                self.detail._onresponse(data)

{hyperquant-0.37 → hyperquant-0.39}/src/hyperquant/broker/ourbit.py

@@ -1,6 +1,7 @@
+import asyncio
 from typing import Literal, Optional
 import pybotters
-from .models.ourbit import OurbitSwapDataStore
+from .models.ourbit import OurbitSwapDataStore, OurbitSpotDataStore
 from decimal import Decimal, ROUND_HALF_UP
 
 
@@ -33,6 +34,7 @@ class OurbitSwap:
             f"{self.api_url}/api/v1/private/order/list/open_orders?page_size=200",
             f"{self.api_url}/api/v1/private/account/assets",
             f"{self.api_url}/api/v1/contract/ticker",
+            f"{self.api_url}/api/platform/spot/market/v2/symbols"
         ]
 
         url_map = {
@@ -306,3 +308,191 @@ class OurbitSwap:
             f"{self.api_url}/api/v1/private/order/deal_details/{order_id}",
         )
         return self.ret_content(res)
+
+
+class OurbitSpot:
+
+    def __init__(self, client: pybotters.Client):
+        """
+        ✅ 完成:
+            下单, 撤单, 查询资金, 查询持有订单, 查询历史订单
+
+        """
+        self.client = client
+        self.store = OurbitSpotDataStore()
+        self.api_url = "https://www.ourbit.com"
+        self.ws_url = "wss://www.ourbit.com/ws"
+
+    async def __aenter__(self) -> "OurbitSpot":
+        client = self.client
+        await self.store.initialize(
+            client.get(f"{self.api_url}/api/platform/spot/market/v2/symbols")
+        )
+        return self
+
+    async def update(self, update_type: Literal["orders", "balance", "ticker", "book", "all"] = "all"):
+
+        all_urls = [
+            f"{self.api_url}/api/platform/spot/order/current/orders/v2?orderTypes=1%2C2%2C3%2C4%2C5%2C100&pageNum=1&pageSize=100&states=0%2C1%2C3",
+            f"{self.api_url}/api/assetbussiness/asset/spot/statistic",
+            f"{self.api_url}/api/platform/spot/market/v2/tickers"
+        ]
+
+        # orderTypes=1%2C2%2C3%2C4%2C5%2C100&pageNum=1&pageSize=100&states=0%2C1%2C3
+        
+        url_map = {
+            "orders": [all_urls[0]],
+            "balance": [all_urls[1]],
+            "ticker": [all_urls[2]],
+            "all": all_urls
+        }
+
+        try:
+            urls = url_map[update_type]
+        except KeyError:
+            raise ValueError(f"Unknown update type: {update_type}")
+        
+        # 直接传协程进去，initialize 会自己 await
+        await self.store.initialize(*(self.client.get(url) for url in urls))
+
+
+    async def sub_personal(self):
+        """订阅个人频道"""
+        # https://www.ourbit.com/ucenter/api/ws_token
+        res = await self.client.fetch(
+            'GET', f"{self.api_url}/ucenter/api/ws_token"
+        )
+
+        token = res.data['data'].get("wsToken")
+
+
+        self.client.ws_connect(
+            f"{self.ws_url}?wsToken={token}&platform=web",
+            send_json={
+                "method": "SUBSCRIPTION",
+                "params": [
+                    "spot@private.orders",
+                    "spot@private.trigger.orders",
+                    "spot@private.balances"
+                ],
+                "id": 1
+            },
+            hdlr_json=self.store.onmessage
+        )
+
+    async def sub_orderbook(self, symbols: str | list[str]):
+        """订阅订单簿深度数据
+        
+        Args:
+            symbols: 交易对符号，可以是单个字符串或字符串列表
+        """
+        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}")
+
+        # 订阅WebSocket深度数据
+        self.client.ws_connect(
+            'wss://www.ourbit.com/ws?platform=web',
+            send_json={
+                "method": "SUBSCRIPTION",
+                "params": subscription_params,
+                "id": 2
+            },
+            hdlr_json=self.store.onmessage
+        )
+
+    async def place_order(
+        self,
+        symbol: str,
+        side: Literal["buy", "sell"],
+        price: float,
+        quantity: float = None,
+        order_type: Literal["market", "limit"] = "limit",
+        usdt_amount: float = None
+    ):
+        """现货下单
+        
+        Args:
+            symbol: 交易对，如 "SOL_USDT"
+            side: 买卖方向 "buy" 或 "sell"
+            price: 价格
+            quantity: 数量
+            order_type: 订单类型 "market" 或 "limit"
+            usdt_amount: USDT金额，如果指定则根据价格计算数量
+            
+        Returns:
+            订单响应数据
+        """
+        # 解析交易对
+        currency, market = symbol.split("_")
+
+        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')
+
+        
+        # 如果指定了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)
+        
+        # 构建请求数据
+        data = {
+            "currency": currency,
+            "market": market,
+            "tradeType": side.upper(),
+            "quantity": str(quantity),
+        }
+        
+        if order_type == "limit":
+            data["orderType"] = "LIMIT_ORDER"
+            data["price"] = str(price)
+        elif order_type == "market":
+            data["orderType"] = "MARKET_ORDER"
+            # 市价单通常不需要价格参数
+        
+        res = await self.client.fetch(
+            "POST", 
+            f"{self.api_url}/api/platform/spot/order/place", 
+            json=data
+        )
+        
+        # 处理响应
+        match res.data:
+            case {"msg": 'success'}:
+                return res.data["data"]
+            case _:
+                raise Exception(f"Failed to place order: {res.data}")

{hyperquant-0.37 → hyperquant-0.39}/src/hyperquant/broker/ws.py

@@ -1,6 +1,9 @@
 import asyncio
 import pybotters
 from pybotters.ws import ClientWebSocketResponse, logger
+from pybotters.auth import Hosts
+import yarl
+
 
 class Heartbeat:
     @staticmethod
@@ -8,8 +11,14 @@ class Heartbeat:
         while not ws.closed:
             await ws.send_str('{"method":"ping"}')
             await asyncio.sleep(10.0)
+    
+    async def ourbit_spot(ws: pybotters.ws.ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_str('{"method":"ping"}')
+            await asyncio.sleep(10.0)
 
 pybotters.ws.HeartbeatHosts.items['futures.ourbit.com'] = Heartbeat.ourbit
+pybotters.ws.HeartbeatHosts.items['www.ourbit.com'] = Heartbeat.ourbit_spot
 
 class WssAuth:
     @staticmethod
@@ -34,4 +43,6 @@ class WssAuth:
                 else:
                     logger.warning(f"WebSocket login failed: {data}")
 
+
+
 pybotters.ws.AuthHosts.items['futures.ourbit.com'] = pybotters.auth.Item("ourbit", WssAuth.ourbit)

{hyperquant-0.37 → hyperquant-0.39}/test.py

@@ -41,6 +41,8 @@ async def test():
             price=192
         )
         print(res)
+
+        
         # # await ourbit.update('orders')
         # await ourbit.sub_personal()
 

hyperquant-0.39/tmp.py

@@ -0,0 +1,115 @@
+import asyncio
+import random
+import time
+import pybotters
+import hyperquant
+from hyperquant.broker.models.ourbit import OurbitSpotDataStore
+from hyperquant.broker.ourbit import OurbitSpot
+
+
+async def main():
+    store = OurbitSpotDataStore()
+
+    async with pybotters.Client(
+        apis={
+            "ourbit": [
+                "WEB3bf088f8b2f2fae07592fe1a6240e2d798100a9cb2a91f8fda1056b6865ab3ee"
+            ]
+        }
+    ) as client:
+        res = await client.fetch("POST", "https://www.ourbit.com/ucenter/api/user_info")
+
+        ob_spot = OurbitSpot(client)
+        await ob_spot.__aenter__()
+        await ob_spot.sub_personal()
+        await ob_spot.update('ticker')
+        print(ob_spot.store.ticker.find())
+
+        # while True:
+        #     await ob_spot.store.balance.wait()
+        #     print(ob_spot.store.balance.find())
+        return
+
+        await store.initialize(
+            client.get("https://www.ourbit.com/api/platform/spot/market/v2/tickers")
+        )
+
+        print(store.ticker.find())
+
+        return
+
+        await store.initialize(
+            client.get(
+                "https://www.ourbit.com/api/platform/spot/market/depth?symbol=XRP_USDT"
+            )
+        )
+
+        print(store.book.find())
+
+        client.ws_connect(
+            "wss://www.ourbit.com/ws?platform=web",
+            send_json={
+                "method": "SUBSCRIPTION",
+                "params": ["spot@public.increase.aggre.depth@XRP_USDT"],
+                "id": 3,
+            },
+            hdlr_json=store.onmessage,
+        )
+        while True:
+            await store.book.wait()
+            # await asyncio.sleep(1)
+            print(store.book.find())
+            # print(store.book.find({'s': 'XRP_USDT', 'S': 'a'}))
+            # print(store.book.find({'s': 'XRP_USDT', 'S': 'b' }))
+            # print(store.book.find())
+            # ts = time.time()*1000
+            # book = store.book.sorted({'s': 'XRP_USDT'}, 1)
+            # print(f'排序耗时: {time.time()*1000 - ts:.2f} ms')
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+# import aiohttp
+# import asyncio
+
+# async def fetch_orders():
+#     url = "https://www.ourbit.com/api/platform/spot/order/current/orders/v2"
+#     params = {
+#         "orderTypes": "1,2,3,4,5,100",
+#         "pageNum": "1",
+#         "pageSize": "100",
+#         "states": "0,1,3"
+#     }
+#     headers = {
+#         "accept": "*/*",
+#         "accept-language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6",
+#         "baggage": "sentry-environment=prd,sentry-release=production%20-%20v3.28.8%20-%20cc4977f,sentry-public_key=48c007e1b13c063127c3119a97a2dd0e,sentry-trace_id=20b4bba185e143428bce7e3aeb376b63,sentry-sample_rate=0.1,sentry-sampled=true",
+#         "cache-control": "no-cache",
+#         "language": "zh-CN",
+#         "luminex-trace-id": "0a4def65-f9ed-47df-8d72-7574abac2ae8-0100",
+#         "luminex-uid": "31204775",
+#         "pragma": "akamai-x-cache-on",
+#         "priority": "u=1, i",
+#         "referer": "https://www.ourbit.com/zh-CN/exchange/BTC_USDT",
+#         "sec-ch-ua": '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"',
+#         "sec-ch-ua-mobile": "?0",
+#         "sec-ch-ua-platform": '"macOS"',
+#         "sec-fetch-dest": "empty",
+#         "sec-fetch-mode": "cors",
+#         "sec-fetch-site": "same-origin",
+#         "sentry-trace": "20b4bba185e143428bce7e3aeb376b63-99fc208a301b8675-1",
+#         "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0"
+#     }
+#     cookies = {
+#         "uc_token": "WEB3bf088f8b2f2fae07592fe1a6240e2d798100a9cb2a91f8fda1056b6865ab3ee",
+#         "u_id": "WEB3bf088f8b2f2fae07592fe1a6240e2d798100a9cb2a91f8fda1056b6865ab3ee",
+#     }
+
+#     async with aiohttp.ClientSession(headers=headers, cookies=cookies) as session:
+#         async with session.get(url, params=params) as resp:
+#             data = await resp.json()
+#             print(data)
+
+# if __name__ == "__main__":
+#     asyncio.run(fetch_orders())

{hyperquant-0.37 → hyperquant-0.39}/uv.lock

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

hyperquant-0.37/src/hyperquant/broker/auth.py

@@ -1,55 +0,0 @@
-import time
-import hashlib
-from typing import Any
-from aiohttp import ClientWebSocketResponse
-from multidict import CIMultiDict
-from yarl import URL
-import pybotters
-import json as pyjson
-from urllib.parse import urlencode
-
-
-def md5_hex(s: str) -> str:
-    return hashlib.md5(s.encode("utf-8")).hexdigest()
-
-
-# 🔑 Ourbit 的鉴权函数
-class Auth:
-    @staticmethod
-    def ourbit(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
-        method: str = args[0]
-        url: URL = args[1]
-        data = kwargs.get("data") or {}
-        headers: CIMultiDict = kwargs["headers"]
-
-        # 从 session 里取 token
-        session = kwargs["session"]
-        token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
-
-        # 时间戳 & body
-        now_ms = int(time.time() * 1000)
-        raw_body_for_sign = data if isinstance(data, str) else pyjson.dumps(data, separators=(",", ":"), ensure_ascii=False)
-
-        # 签名
-        mid_hash = md5_hex(f"{token}{now_ms}")[7:]
-        final_hash = md5_hex(f"{now_ms}{raw_body_for_sign}{mid_hash}")
-
-        # 设置 headers
-        headers.update({
-            "Authorization": token,
-            "Language": "Chinese",
-            "language": "Chinese",
-            "Content-Type": "application/json",
-            "x-ourbit-sign": final_hash,
-            "x-ourbit-nonce": str(now_ms),
-        })
-
-        # 更新 kwargs.body，保证发出去的与签名一致
-        kwargs.update({"data": raw_body_for_sign})
-    
-        return args
-    
-
-pybotters.auth.Hosts.items['futures.ourbit.com'] = pybotters.auth.Item("ourbit", Auth.ourbit)
-
-