hyperquant 0.61__tar.gz → 0.63__tar.gz

{hyperquant-0.61 → hyperquant-0.63}/PKG-INFO

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

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

hyperquant-0.63/src/hyperquant/broker/lbank.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import logging
+import time
+import zlib
+from typing import Iterable, Literal
+
+import pybotters
+
+from .models.lbank import LbankDataStore
+
+logger = logging.getLogger(__name__)
+
+# https://ccapi.rerrkvifj.com 似乎是spot的api
+# https://uuapi.rerrkvifj.com 似乎是合约的api
+
+
+class Lbank:
+    """LBank public market-data client (REST + WS)."""
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        front_api: str | None = None,
+        rest_api: str | None = None,
+        ws_url: str | None = None,
+    ) -> None:
+        self.client = client
+        self.store = LbankDataStore()
+        self.front_api = front_api or "https://uuapi.rerrkvifj.com"
+        self.rest_api = rest_api or "https://api.lbkex.com"
+        self.ws_url = ws_url or "wss://uuws.rerrkvifj.com/ws/v3"
+        self._req_id = itertools.count(int(time.time() * 1000))
+        self._ws_app = None
+
+    async def __aenter__(self) -> "Lbank":
+        await self.update("detail")
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        pass
+
+    async def update(self, update_type: Literal["detail", "ticker", "all"]) -> list[dict]:
+        all_urls = [f"{self.front_api}/cfd/agg/v1/instrument"]
+        url_map = {"detail": [all_urls[0]], "all": all_urls}
+
+
+        try:
+            urls = url_map[update_type]
+        except KeyError:
+            raise ValueError(f"update_type err: {update_type}")
+
+        # await self.store.initialize(*(self.client.get(url) for url in urls))
+        if update_type == "detail" or update_type == "all":
+            await self.store.initialize(
+                self.client.post(
+                    all_urls[0],
+                    json={"ProductGroup": "SwapU"},
+                    headers={"source": "4", "versionflage": "true"},
+                )
+            )
+
+
+    async def sub_orderbook(self, symbols: list[str], limit: int | None = None) -> None:
+        """订阅指定交易对的订单簿（遵循 LBank 协议）。
+        """
+
+        send_jsons = []
+        y = 3000000001
+        if limit:
+            self.store.book.limit = limit
+
+        for symbol in symbols:
+
+            info = self.store.detail.get({"symbol": symbol})
+            if not info:
+                raise ValueError(f"Unknown LBank symbol: {symbol}")
+            
+            tick_size = info['tick_size']
+            sub_i = symbol + "_" + str(tick_size) + "_25"
+            send_jsons.append(
+                {
+                    "x": 3,
+                    "y": str(y),
+                    "a": {"i": sub_i},
+                    "z": 1,
+                }
+            )
+
+            self.store.register_book_channel(str(y), symbol)
+            y += 1
+
+        wsapp = self.client.ws_connect(
+            self.ws_url,
+            send_json=send_jsons,
+            hdlr_bytes=self.store.onmessage,
+        )
+
+        await wsapp._event.wait()

hyperquant-0.63/src/hyperquant/broker/models/lbank.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Awaitable, TYPE_CHECKING
+
+from aiohttp import ClientResponse
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+logger = logging.getLogger(__name__)
+
+
+def _accuracy_to_step(accuracy: int | str | None) -> str:
+    try:
+        n = int(accuracy) if accuracy is not None else 0
+    except (TypeError, ValueError):  # pragma: no cover - defensive guard
+        n = 0
+    if n <= 0:
+        return "1"
+    return "0." + "0" * (n - 1) + "1"
+
+
+class Book(DataStore):
+    """LBank order book store parsed from the depth channel."""
+
+    _KEYS = ["id", "S", "p"]
+
+    def _init(self) -> None:
+        self.limit: int | None = None
+        self.symbol_map: dict[str, str] = {}
+
+
+    def _format_levels(
+        self,
+        levels: list[list[Any]],
+        channel_id: str | None,
+        side: str,
+        symbol: str | None,
+    ) -> list[dict[str, Any]]:
+        formatted: list[dict[str, Any]] = []
+        for level in levels:
+            if len(level) < 2:
+                continue
+            try:
+                price = float(level[0])
+                size = float(level[1])
+            except (TypeError, ValueError):  # pragma: no cover - defensive guard
+                continue
+            formatted.append(
+                {
+                    "id": channel_id,
+                    "S": side,
+                    "p": price,
+                    "q": size,
+                    "s": symbol,
+                }
+            )
+        if self.limit is not None:
+            formatted = formatted[: self.limit]
+        return formatted
+
+    def _on_message(self, msg: Any) -> None:
+        
+        data = json.loads(msg)
+        
+        if not data:
+            return
+
+        channel_id = None
+        if data.get("y") is not None:
+            channel_id = str(data["y"])
+
+        symbol = None
+        if channel_id:
+            symbol = self.symbol_map.get(channel_id)
+        if symbol is None and data.get("i"):
+            symbol = self.symbol_map.get(str(data["i"]))
+
+        bids = self._format_levels(data.get("b", []), channel_id, "b", symbol)
+        asks = self._format_levels(data.get("s", []), channel_id, "a", symbol)
+
+        if not (bids or asks):
+            return
+
+        if channel_id is not None:
+            self._find_and_delete({"id": channel_id})
+        self._insert(bids + asks)
+
+
+class Detail(DataStore):
+    """Futures instrument metadata store obtained from the futures instrument endpoint."""
+
+    _KEYS = ["symbol"]
+
+    def _transform(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        try:
+            instrument:dict = entry["instrument"]
+            fee:dict = entry["fee"]
+            market_data:dict = entry["marketData"]
+        except (KeyError, TypeError):
+            return None
+        return {
+            "symbol": instrument.get("instrumentID"),
+            "instrument_name": instrument.get("instrumentName"),
+            "base_currency": instrument.get("baseCurrency"),
+            "price_currency": instrument.get("priceCurrency"),
+            "min_order_volume": instrument.get("minOrderVolume"),
+            "max_order_volume": instrument.get("maxOrderVolume"),
+            "tick_size": instrument.get("priceTick"),
+            "step_size": instrument.get("volumeTick"),
+            "maker_fee": fee.get("makerOpenFeeRate"),
+            "taker_fee": fee.get("takerOpenFeeRate"),
+            "last_price": market_data.get("lastPrice"),
+            "amount24": market_data.get("turnover24"),
+        }
+
+    def _onresponse(self, data: list[dict[str, Any]] | dict[str, Any] | None) -> None:
+        if not data:
+            self._clear()
+            return
+        entries = data
+        if isinstance(data, dict):  # pragma: no cover - defensive guard
+            entries = data.get("data") or []
+        items: list[dict[str, Any]] = []
+        for entry in entries or []:
+            transformed = self._transform(entry)
+            if transformed:
+                items.append(transformed)
+        if not items:
+            self._clear()
+            return
+        self._clear()
+        self._insert(items)
+
+
+class LbankDataStore(DataStoreCollection):
+    """Aggregates book/detail stores for the LBank public feed."""
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._channel_to_symbol: dict[str, str] = {}
+
+    @property
+    def book(self) -> Book:
+        """
+        订单簿（Order Book）数据流，按订阅ID（channel_id）索引。
+
+        此属性表示通过深度频道（depth channel）接收到的订单簿快照和增量更新，数据结构示例如下：
+
+        Data structure:
+            [
+                {
+                    "id": <channel_id>,
+                    "S": "b" 或 "a",  # "b" 表示买单，"a" 表示卖单
+                    "p": <价格>,
+                    "q": <数量>,
+                    "s": <标准化交易对符号>
+                },
+                ...
+            ]
+
+        通过本属性可以获取当前 LBank 订单簿的最新状态，便于后续行情分析和撮合逻辑处理。
+        """
+        return self._get("book")
+
+    @property
+    def detail(self) -> Detail:
+        """
+
+        _KEYS = ["symbol"]
+
+        期货合约详情元数据流。
+
+        此属性表示通过期货合约接口获取的合约详情，包括合约ID、合约名称、基础币种、计价币种、最小/最大下单量、价格跳动、交易量跳动、maker/taker手续费率、最新价和24小时成交额等信息。
+
+        Data structure:
+            [
+                {
+                    "symbol": "BTCUSDT",               # 合约ID
+                    "instrument_name": "BTCUSDT",      # 合约名称
+                    "base_currency": "BTC",            # 基础币种
+                    "price_currency": "USDT",          # 计价币种
+                    "min_order_volume": "0.0001",        # 最小下单量
+                    "max_order_volume": "600.0",         # 最大下单量
+                    "tick_size": "0.1",                  # 最小价格变动单位
+                    "step_size": "0.0001",               # 最小数量变动单位
+                    "maker_fee": "0.0002",               # Maker 手续费率
+                    "taker_fee": "0.0006",               # Taker 手续费率
+                    "last_price": "117025.5",            # 最新价
+                    "amount24": "807363493.97579747"     # 24小时成交额
+                },
+                ...
+            ]
+
+        通过本属性可以获取所有支持的期货合约元数据，便于下单参数校验和行情展示。
+        """
+        return self._get("detail")
+
+
+    def register_book_channel(self, channel_id: str, symbol: str, *, raw_symbol: str | None = None) -> None:
+        if channel_id is not None:
+            self.book.symbol_map[str(channel_id)] = symbol
+        if raw_symbol:
+            self.book.symbol_map[str(raw_symbol)] = symbol
+
+
+    async def initialize(self, *aws: Awaitable[ClientResponse]) -> None:
+        for fut in asyncio.as_completed(aws):
+            res = await fut
+            data = await res.json()
+            if res.url.path == "/cfd/agg/v1/instrument":
+                self.detail._onresponse(data)
+
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        self.book._on_message(msg)

{hyperquant-0.61 → hyperquant-0.63}/src/hyperquant/broker/ws.py

@@ -26,9 +26,16 @@ class Heartbeat:
             await ws.send_json({"type": "ping", "time": now})
             await asyncio.sleep(20.0)
 
+    @staticmethod
+    async def lbank(ws: ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_str('ping')
+            await asyncio.sleep(6)
+
 pybotters.ws.HeartbeatHosts.items['futures.ourbit.com'] = Heartbeat.ourbit
 pybotters.ws.HeartbeatHosts.items['www.ourbit.com'] = Heartbeat.ourbit_spot
 pybotters.ws.HeartbeatHosts.items['quote.edgex.exchange'] = Heartbeat.edgex
+pybotters.ws.HeartbeatHosts.items['uuws.rerrkvifj.com'] = Heartbeat.lbank
 
 class WssAuth:
     @staticmethod

hyperquant-0.63/tests/test_edgex.py

@@ -0,0 +1,27 @@
+from hyperquant.broker.edgex import Edgex
+import pybotters
+async def main():
+    async with pybotters.Client() as client:
+        async with Edgex(client) as broker:
+            # print(broker.store.detail.find({
+            #     'contractName': 'BTCUSD',
+            # }))
+
+            await broker.sub_orderbook(symbols=['BTCUSD'])
+            broker.store.book.limit = 1
+            while True:
+               print(broker.store.book.find({"S": 'b'}))
+               await asyncio.sleep(1)
+
+            # await broker.sub_ticker(all_contracts=True, periodic=True)
+            # broker.store.book.limit = 1
+            # while True:
+            #     print(broker.store.ticker.find({
+            #         's':'BTCUSD',
+            #     }))
+            #     await asyncio.sleep(1)
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

hyperquant-0.63/tests/test_lbank.py

@@ -0,0 +1,85 @@
+import asyncio
+import zlib
+from aiohttp import ClientWebSocketResponse
+import pybotters
+
+
+def callback(msg, ws: ClientWebSocketResponse = None):
+    # print("Received message:", msg)
+    decompressed = zlib.decompress(msg, 16 + zlib.MAX_WBITS)
+    text = decompressed.decode("utf-8")
+    print(f"Decoded text: {text}")
+
+def callback2(msg, ws: ClientWebSocketResponse = None):
+    # print("Received message:", msg)
+    print(str(msg))
+
+
+async def main():
+    async with pybotters.Client() as client:
+        # webData2
+        client.ws_connect(
+            "wss://ccws.rerrkvifj.com/ws/V3/",
+            send_json={
+                "dataType": 3,
+                "depth": 200,
+                "pair": "arb_usdt",
+                "action": "subscribe",
+                "subscribe": "depth",
+                "msgType": 2,
+                "limit": 10,
+                "type": 10000,
+            },
+            hdlr_bytes=callback,
+        )
+
+        while True:
+            await asyncio.sleep(1)
+
+
+async def main2():
+    async with pybotters.Client() as client:
+        # webData2
+        # x 为chanel, y为唯一标识, a为参数, z为版本号
+        client.ws_connect(
+            "wss://uuws.rerrkvifj.com/ws/v3",
+            send_json={"x": 3, "y": "3000000001", "a": {"i": "BTCUSDT_0.1_25"}, "z": 1},
+            hdlr_bytes=callback2,
+        )
+
+        while True:
+            await asyncio.sleep(1)
+
+from hyperquant.broker.lbank import Lbank
+
+async def test_broker():
+    async with pybotters.Client() as client:
+        async with Lbank(client) as lb:
+            print(lb.store.detail.find())
+
+
+async def test_broker_detail():
+    async with pybotters.Client() as client: 
+        data = await client.post(
+            "https://uuapi.rerrkvifj.com/cfd/agg/v1/instrument",
+            headers={"source": "4", "versionflage": "true"},
+            json={
+            "ProductGroup": "SwapU"
+            }
+        ) 
+        res = await data.json()
+        print(res)
+
+async def test_broker_subbook():
+    async with pybotters.Client() as client:
+        async with Lbank(client) as lb:
+            # 取20个symbol 尝试是否可以订阅成功
+            symbols = [item["symbol"] for item in lb.store.detail.find()[:4]]
+            await lb.sub_orderbook(symbols, limit=1)
+            while True:
+                await asyncio.sleep(1)
+                print(len(lb.store.book.find()))
+
+
+if __name__ == "__main__":
+    asyncio.run(test_broker_subbook())

{hyperquant-0.61 → hyperquant-0.63}/uv.lock

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

hyperquant-0.61/tests/test_edgex.py

@@ -1,26 +0,0 @@
-from hyperquant.broker.edgex import Edgex
-import pybotters
-async def main():
-    async with pybotters.Client() as client:
-        async with Edgex(client) as broker:
-            # print(broker.store.detail.find({
-            #     'contractName': 'BTCUSD',
-            # }))
-
-            # await broker.sub_orderbook(symbols=['BTCUSD'])
-            # broker.store.book.limit = 1
-            # while True:
-            #    print(broker.store.book.find({"S": 'b'}))
-            #    await asyncio.sleep(1)
-
-            await broker.sub_ticker(all_contracts=True, periodic=True)
-            while True:
-                print(broker.store.ticker.find({
-                    's':'BTCUSD',
-                }))
-                await asyncio.sleep(1)
-
-
-if __name__ == "__main__":
-    import asyncio
-    asyncio.run(main())

hyperquant-0.61/tests/test_lbank.py

@@ -1,34 +0,0 @@
-import asyncio
-import zlib
-from aiohttp import ClientWebSocketResponse
-import pybotters
-
-def callback(msg, ws: ClientWebSocketResponse = None):
-    # print("Received message:", msg)
-    decompressed = zlib.decompress(msg, 16 + zlib.MAX_WBITS)
-    text = decompressed.decode("utf-8")
-    print(f"Decoded text: {text}")
-
-async def main():
-    async with pybotters.Client() as client:
-        # webData2
-        client.ws_connect(
-            "wss://ccws.rerrkvifj.com/ws/V3/",
-            send_json={
-                "dataType": 3,
-                "depth": 200,
-                "pair": "arb_usdt",
-                "action": "subscribe",
-                "subscribe": "depth",
-                "msgType": 2,
-                "limit": 10,
-                "type": 10000
-            },
-            hdlr_bytes=callback
-        )
-
-        while True:
-            await asyncio.sleep(1)
-
-if __name__ == "__main__":
-    asyncio.run(main())