hyperquant 0.69__tar.gz → 0.72__tar.gz

{hyperquant-0.69 → hyperquant-0.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.69
+Version: 0.72
 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.69 → hyperquant-0.72}/apis.json

@@ -7,7 +7,10 @@
     "78Uke-bPB57YoRzAwY7SkWyPQFeKkPuWVQakC0k9rSI",
     "3MB7nAnnNPTxAnwdbjDPew-02b746d6a832346a46a97faf054b2909c1a0b58a35e04c3504923a99a5503c1c"
   ],
-  "lbank": [
-    "617a2d77b4cd4dfbbaa2094c17017bdb"
+  "lbank": ["617a2d77b4cd4dfbbaa2094c17017bdb"],
+  "bitget": [
+    "bg_03e0445d9282f248d22842cfe6f30192",
+    "67ec894753d75fec12332881278420863a960ec39c8f5acf1de88aa1da926854",
+    "huainian0408"
   ]
 }

{hyperquant-0.69 → hyperquant-0.72}/pyproject.toml

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

hyperquant-0.72/src/hyperquant/broker/bitget.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Literal
+
+import pybotters
+
+from .models.bitget import BitgetDataStore
+from .lib.util import fmt_value
+
+logger = logging.getLogger(__name__)
+
+
+class Bitget:
+    """Bitget public/privileged client (REST + WS).
+
+    默认只支持单向持仓（One-way mode）。
+    """
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        rest_api: str | None = None,
+        ws_url: str | None = None,
+    ) -> None:
+        self.client = client
+        self.store = BitgetDataStore()
+
+        self.rest_api = rest_api or "https://api.bitget.com"
+        self.ws_url = ws_url or "wss://ws.bitget.com/v2/ws/public"
+        self.ws_url_private = ws_url or "wss://ws.bitget.com/v2/ws/private"
+
+        self._ws_app = None
+
+    async def __aenter__(self) -> "Bitget":
+        await self.update("detail")
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # pragma: no cover - symmetry
+        pass
+
+    async def sub_personal(self) -> None:
+        sub_msg = {
+            "op": "subscribe",
+            "args": [
+                {"instType": "USDT-FUTURES", "channel": "orders", "instId": "default"},
+                {
+                    "instType": "USDT-FUTURES",
+                    "channel": "positions",
+                    "instId": "default",
+                },
+                {"instType": "USDT-FUTURES", "channel": "account", "coin": "default"},
+            ],
+        }
+        self.client.ws_connect(
+            self.ws_url_private,
+            send_json=sub_msg,
+            hdlr_json=self.store.onmessage,
+        )
+
+    async def update(
+        self,
+        update_type: Literal["detail", "ticker", "all"] = "all",
+    ) -> None:
+        """Refresh cached REST resources."""
+
+        requests: list[Any] = []
+
+        if update_type in {"detail", "all"}:
+            requests.append(
+                self.client.get(
+                    f"{self.rest_api}/api/v2/mix/market/contracts",
+                    params={"productType": "usdt-futures"},
+                )
+            )
+
+        if update_type in {"ticker", "all"}:
+            requests.append(
+                self.client.get(
+                    f"{self.rest_api}/api/v2/mix/market/tickers",
+                    params={"productType": "usdt-futures"},
+                )
+            )
+
+        if not requests:
+            raise ValueError(f"update_type err: {update_type}")
+
+        await self.store.initialize(*requests)
+
+    async def place_order(
+        self,
+        symbol: str,
+        *,
+        direction: Literal["buy", "sell", "long", "short", "0", "1"],
+        volume: float,
+        price: float | None = None,
+        order_type: Literal[
+            "market",
+            "limit_gtc",
+            "limit_ioc",
+            "limit_fok",
+            "limit_post_only",
+            "limit",
+        ] = "market",
+        margin_mode: Literal["isolated", "crossed"] = "crossed",
+        product_type: str = "USDT-FUTURES",
+        margin_coin: str = "USDT",
+        reduce_only: bool | None = None,
+        offset_flag: Literal["open", "close", "0", "1"] | None = None,
+        client_order_id: str | None = None,
+        extra_params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Create an order via ``POST /api/v2/mix/order/place-order``.
+
+        Parameters mirror the Bitget V2 contract REST API but are normalized to
+        match the broker interface (``direction``, ``order_type`` etc.).
+        """
+
+        side = self._normalize_direction(direction)
+        order_type_code, force_code = self._resolve_order_type(order_type)
+
+        if reduce_only is None:
+            reduce_only = self._normalize_offset(offset_flag)
+
+        detail = self._get_detail_entry(symbol)
+        volume_str = self._format_with_step(
+            volume, detail.get("step_size") or detail.get("stepSize")
+        )
+
+        payload: dict[str, Any] = {
+            "symbol": symbol,
+            "productType": product_type,
+            "marginMode": margin_mode,
+            "marginCoin": margin_coin,
+            "side": side,
+            "size": volume_str,
+            "orderType": order_type_code,
+        }
+
+        if force_code:
+            payload["force"] = force_code
+
+        if order_type_code == "limit":
+            if price is None:
+                raise ValueError("price is required for Bitget limit orders")
+            payload["price"] = self._format_with_step(
+                price,
+                detail.get("tick_size") or detail.get("tickSize"),
+            )
+        elif price is not None:
+            logger.debug("Price %.8f ignored for market order", price)
+
+        if reduce_only is True:
+            payload["reduceOnly"] = "YES"
+        elif reduce_only is False:
+            payload["reduceOnly"] = "NO"
+
+        if client_order_id:
+            payload["clientOid"] = client_order_id
+
+        if extra_params:
+            payload.update(extra_params)
+
+        res = await self.client.post(
+            f"{self.rest_api}/api/v2/mix/order/place-order",
+            data=payload,
+        )
+        data = await res.json()
+        return self._ensure_ok("place_order", data)
+
+    async def cancel_order(
+        self,
+        order_sys_id: str,
+        *,
+        symbol: str,
+        margin_mode: Literal["isolated", "crossed"],
+        product_type: str = "USDT-FUTURES",
+        margin_coin: str = "USDT",
+        client_order_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Cancel an order via ``POST /api/v2/mix/order/cancel-order``."""
+
+        payload = {
+            "symbol": symbol,
+            "productType": product_type,
+            "marginMode": margin_mode,
+            "marginCoin": margin_coin,
+        }
+
+        if client_order_id:
+            payload["clientOid"] = client_order_id
+        else:
+            payload["orderId"] = order_sys_id
+
+        res = await self.client.post(
+            f"{self.rest_api}/api/v2/mix/order/cancel-order",
+            json=payload,
+        )
+        data = await res.json()
+        return self._ensure_ok("cancel_order", data)
+
+    async def sub_orderbook(self, symbols: list[str], channel: str = "books1") -> None:
+        """Subscribe to Bitget order-book snapshots/updates."""
+
+        submsg = {"op": "subscribe", "args": []}
+        for symbol in symbols:
+            submsg["args"].append(
+                {"instType": "SPOT", "channel": channel, "instId": symbol}
+            )
+
+        self.client.ws_connect(
+            self.ws_url,
+            send_json=submsg,
+            hdlr_json=self.store.onmessage,
+        )
+
+    def _get_detail_entry(self, symbol: str) -> dict[str, Any]:
+        detail = self.store.detail.get({"symbol": symbol})
+        if not detail:
+            raise ValueError(
+                f"Unknown Bitget instrument: {symbol}. Call update('detail') first or provide valid symbol."
+            )
+        return detail
+
+    @staticmethod
+    def _format_with_step(value: float, step: Any) -> str:
+        if step in (None, 0, "0"):
+            return str(value)
+        try:
+            step_float = float(step)
+        except (TypeError, ValueError):  # pragma: no cover - defensive guard
+            return str(value)
+        if step_float <= 0:
+            return str(value)
+        return fmt_value(value, step_float)
+
+    @staticmethod
+    def _normalize_direction(direction: str) -> str:
+        mapping = {
+            "buy": "buy",
+            "long": "buy",
+            "0": "buy",
+            "sell": "sell",
+            "short": "sell",
+            "1": "sell",
+        }
+        key = str(direction).lower()
+        try:
+            return mapping[key]
+        except KeyError as exc:  # pragma: no cover - guard
+            raise ValueError(f"Unsupported direction: {direction}") from exc
+
+    @staticmethod
+    def _normalize_offset(
+        offset: Literal["open", "close", "0", "1"] | None,
+    ) -> bool | None:
+        if offset is None:
+            return None
+        mapping = {
+            "open": False,
+            "0": False,
+            "close": True,
+            "1": True,
+        }
+        key = str(offset).lower()
+        if key in mapping:
+            return mapping[key]
+        raise ValueError(f"Unsupported offset_flag: {offset}")
+
+    @staticmethod
+    def _resolve_order_type(order_type: str) -> tuple[str, str | None]:
+        mapping = {
+            "market": ("market", None),
+            "limit": ("limit", "gtc"),
+            "limit_gtc": ("limit", "gtc"),
+            "limit_ioc": ("limit", "ioc"),
+            "limit_fok": ("limit", "fok"),
+            "limit_post_only": ("limit", "post_only"),
+        }
+        key = str(order_type).lower()
+        try:
+            return mapping[key]
+        except KeyError as exc:  # pragma: no cover - guard
+            raise ValueError(f"Unsupported order_type: {order_type}") from exc
+
+    @staticmethod
+    def _ensure_ok(operation: str, data: Any) -> dict[str, Any]:
+        if not isinstance(data, dict) or data.get("code") != "00000":
+            raise RuntimeError(f"{operation} failed: {data}")
+        return data.get("data") or {}

hyperquant-0.72/src/hyperquant/broker/lib/util.py

@@ -0,0 +1,22 @@
+from decimal import ROUND_HALF_UP, Decimal
+
+
+def fmt_value(price: float, tick: float) -> str:
+    tick_dec = Decimal(str(tick))
+    price_dec = Decimal(str(price))
+    return str(
+        (price_dec / tick_dec).quantize(Decimal("1"), rounding=ROUND_HALF_UP) * tick_dec
+    )
+
+
+def place_to_step(place: int) -> float:
+    """
+    把 pricePlace / volumePlace 转换成 tick_size / lot_size
+
+    Args:
+        place (int): 小数位数，例如 pricePlace=1, volumePlace=2
+
+    Returns:
+        float: 步长 (step)，例如 0.1, 0.01
+    """
+    return 10 ** (-place)

hyperquant-0.72/src/hyperquant/broker/models/bitget.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Awaitable
+from aiohttp import ClientResponse
+from pybotters import DataStore
+from pybotters.models.bitget_v2 import BitgetV2DataStore
+from ..lib.util import place_to_step
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+
+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:
+        step_place = entry.get("volume_place", 1)
+        tick_place = entry.get("price_place", 1)
+
+        step_size = place_to_step(step_place)
+        tick_size = place_to_step(tick_place)
+
+        entry["stepSize"] = step_size
+        entry["tickSize"] = tick_size
+        # expose snake_case aliases for downstream callers keeping legacy naming
+        entry["step_size"] = step_size
+        entry["tick_size"] = tick_size
+
+        return entry
+
+    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 Book(DataStore):
+    _KEYS = ["t", "s", "S", "p"]
+
+    def _onmessage(self, msg: Item) -> None:
+        action = msg["action"]
+        inst_type = msg["arg"]["instType"]
+        inst_id = msg["arg"]["instId"]
+
+        data_to_insert = []
+        data_to_update = []
+        data_to_delete = []
+        for book in msg["data"]:
+            for side in ("asks", "bids"):
+                for row in book[side]:
+                    converted_row = {
+                        "t": inst_type,
+                        "s": inst_id,
+                        "S": side[0],
+                        "p": row[0],
+                        "q": row[1],
+                    }
+                    if action == "snapshot":
+                        data_to_insert.append(converted_row)
+                    elif converted_row["q"] != "0":
+                        data_to_update.append(converted_row)
+                    else:
+                        data_to_delete.append(converted_row)
+
+        # Cleanup on reconnect
+        if action == "snapshot":
+            self._find_and_delete({"t": inst_type, "s": inst_id})
+
+        self._insert(data_to_insert)
+        self._update(data_to_update)
+        self._delete(data_to_delete)
+    
+    def sorted(
+        self, query: Item | None = None, limit: int | None = None
+    ) -> dict[str, list[Item]]:
+        return self._sorted(
+            item_key="side",
+            item_asc_key="a",
+            item_desc_key="b",
+            sort_key="p",
+            query=query,
+            limit=limit,
+        )
+
+
+class BitgetDataStore(BitgetV2DataStore):
+
+    def _init(self):
+        super()._init()
+        self._create('detail', datastore_class=Detail)
+        self._create("book", datastore_class=Book)
+        
+    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 == '/api/v2/mix/market/contracts':
+                self.detail._onresponse(data)
+            elif res.url.path == '/api/v2/mix/market/tickers':
+                self.ticker._clear()
+                tickers = data.get('data', [])
+                # 为每个ticker添加额外的字段
+                for ticker in tickers:
+                    symbol = ticker.get('symbol')
+                    ticker['instId'] = symbol
+                    ticker['instType'] = 'futures'
+
+                self.ticker._update(tickers)
+    
+    @property
+    def detail(self) -> Detail:
+        """
+        _key: symbol
+
+        Data Structure:
+
+        .. code:: json
+
+            [
+                {
+                "symbol": "BTCUSDT",
+                "baseCoin": "BTC",
+                "quoteCoin": "USDT",
+                "buyLimitPriceRatio": "0.9",
+                "sellLimitPriceRatio": "0.9",
+                "feeRateUpRatio": "0.1",
+                "makerFeeRate": "0.0004",
+                "takerFeeRate": "0.0006",
+                "openCostUpRatio": "0.1",
+                "supportMarginCoins": [
+                    "USDT"
+                ],
+                "minTradeNum": "0.01",
+                "priceEndStep": "1",
+                "volumePlace": "2",
+                "stepSize": "0.01",
+                "tickSize": "0.1",
+                "pricePlace": "1",
+                "sizeMultiplier": "0.01",
+                "symbolType": "perpetual",
+                "minTradeUSDT": "5",
+                "maxSymbolOrderNum": "999999",
+                "maxProductOrderNum": "999999",
+                "maxPositionNum": "150",
+                "symbolStatus": "normal",
+                "offTime": "-1",
+                "limitOpenTime": "-1",
+                "deliveryTime": "",
+                "deliveryStartTime": "",
+                "launchTime": "",
+                "fundInterval": "8",
+                "minLever": "1",
+                "maxLever": "125",
+                "posLimit": "0.05",
+                "maintainTime": "1680165535278",
+                "maxMarketOrderQty": "220",
+                "maxOrderQty": "1200"
+            }]
+        
+        """
+        return self._get('detail')
+    
+    @property
+    def ticker(self) -> DataStore:
+        """
+        _KEYS = ["instType", "instId"]
+
+        Data Structure:
+
+        .. code:: json
+
+            [
+                {
+                    "symbol": "BTCUSDT",
+                    "lastPr": "111534.6",
+                    "askPr": "111534.6",
+                    "bidPr": "111534.5",
+                    "bidSz": "23.7924",
+                    "askSz": "8.1762",
+                    "high24h": "112300",
+                    "low24h": "109136.2",
+                    "ts": "1759115725508",
+                    "change24h": "0.01906",
+                    "baseVolume": "35520.11438048",
+                    "quoteVolume": "3932280581.066103549",
+                    "usdtVolume": "3932280581.066103549",
+                    "openUtc": "112100",
+                    "changeUtc24h": "-0.00504",
+                    "indexPrice": "111587.6090439271505504",
+                    "fundingRate": "-0.000002",
+                    "holdingAmount": "66775.1917",
+                    "deliveryStartTime": null,
+                    "deliveryTime": null,
+                    "deliveryStatus": "",
+                    "open24h": "109448.3",
+                    "markPrice": "111537",
+                    "instId": "BTCUSDT",
+                    "instType": "futures"
+                }
+            ]
+        """
+        return self._get('ticker')
+    
+    @property
+    def orders(self) -> DataStore:
+        """
+        _KEYS = ["instType", "instId", "orderId"]
+        .. code:: json
+
+            [
+                {
+                "instType": "futures",
+                "instId": "BTCUSDT",
+                "orderId": "1",
+                "clientOid": "1",
+                "size": "8.0000",
+                "newSize": "500.0000",
+                "notional": "8.000000",
+                "orderType": "market",
+                "force": "gtc",
+                "side": "buy",
+                "fillPrice": "26256.0",
+                "tradeId": "1",
+                "baseVolume": "0.0003",
+                "fillTime": "1695797773286",
+                "fillFee": "-0.00000018",
+                "fillFeeCoin": "BTC",
+                "tradeScope": "T",
+                "accBaseVolume": "0.0003",
+                "priceAvg": "26256.0",
+                "status": "partially_filled",
+                "cTime": "1695797773257",
+                "uTime": "1695797773326",
+                "stpMode": "cancel_taker",
+                "feeDetail": [
+                    {
+                    "feeCoin": "BTC",
+                    "fee": "-0.00000018"
+                    }
+                ],
+                "enterPointSource": "WEB"
+                }
+            ]
+        """
+        return self._get('orders')
+    
+    @property
+    def book(self) -> DataStore:
+        """
+        _KEYS = ["t", "s", "S", "p"]
+
+        Data Structure:
+
+        .. code:: json
+
+            [
+                {
+                    "t": "futures",
+                    "s": "BTCUSDT",
+                    "S": "a",
+                    "p": "111534.6",
+                    "q": "8.1762"
+                },
+                {
+                    "t": "futures",
+                    "s": "BTCUSDT",
+                    "S": "b",
+                    "p": "111534.5",
+                    "q": "23.7924"
+                }
+            ]
+        """
+        return self._get("book")

{hyperquant-0.69 → hyperquant-0.72}/src/hyperquant/broker/models/lbank.py

@@ -184,7 +184,8 @@ class Orders(DataStore):
             "side": direction,
             "offset": offset_flag,
             "order_type": order_kind,
-            "price": entry.get("Price"),
+            "price": entry.get('TradePrice') or entry.get("Price"),
+            "order_price": entry.get("OrderPrice") or entry.get('Price'),
             "quantity": entry.get("Volume"),
             "filled": entry.get("VolumeTraded"),
             "remaining": entry.get("VolumeRemain"),