hyperquant 0.71__py3-none-any.whl → 0.73__py3-none-any.whl

hyperquant/broker/bitget.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
-import asyncio
-import itertools
 import logging
-import time
-from typing import Any, Iterable, Literal
+from typing import Any, Literal
 
 import pybotters
 
@@ -14,9 +11,11 @@ from .lib.util import fmt_value
 logger = logging.getLogger(__name__)
 
 
-
 class Bitget:
-    """Bitget public market-data client (REST + WS)."""
+    """Bitget public/privileged client (REST + WS).
+
+    默认只支持单向持仓（One-way mode）。
+    """
 
     def __init__(
         self,
@@ -34,74 +33,259 @@ class Bitget:
 
         self._ws_app = None
 
-
     async def __aenter__(self) -> "Bitget":
         await self.update("detail")
         return self
 
-    async def __aexit__(self, exc_type, exc, tb) -> None:
+    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",
+        update_type: Literal["detail", "ticker", "all"] = "all",
     ) -> None:
-        fet = []
-        if update_type in ("detail", "all"):
-            fet.append(
+        """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?productType=usdt-futures",
+                    f"{self.rest_api}/api/v2/mix/market/contracts",
+                    params={"productType": "usdt-futures"},
                 )
             )
-        elif update_type in ("ticker", "all"):
-            fet.append(
+
+        if update_type in {"ticker", "all"}:
+            requests.append(
                 self.client.get(
-                    f"{self.rest_api}/api/v2/mix/market/tickers?productType=usdt-futures",
+                    f"{self.rest_api}/api/v2/mix/market/tickers",
+                    params={"productType": "usdt-futures"},
                 )
             )
-        
-        await self.store.initialize(*fet)
+
+        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", "0", "1"],
+        direction: Literal["buy", "sell", "long", "short", "0", "1"],
         volume: float,
         price: float | None = None,
-        order_type: Literal["market", "limit_ioc", "limit_gtc"] = "market",
-        offset_flag: Literal["open", "close", "0", "1"] = "open",
-        exchange_id: str = "Exchange",
-        product_group: str = "SwapU",
-        order_proportion: str = "0.0000",
+        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]:
-       pass
+        """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,
         *,
-        action_flag: str | int = "1",
+        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]:
-        pass
+        """Cancel an order via ``POST /api/v2/mix/order/cancel-order``."""
 
+        payload = {
+            "symbol": symbol,
+            "productType": product_type,
+            "marginMode": margin_mode,
+            "marginCoin": margin_coin,
+        }
 
-    async def sub_orderbook(self, symbols: list[str], channel: str = 'books1') -> None:
-        """订阅指定交易对的订单簿（遵循 LBank 协议）。
-        """
+        if client_order_id:
+            payload["clientOid"] = client_order_id
+        else:
+            payload["orderId"] = order_sys_id
 
-        submsg = {
-            "op": "subscribe",
-            "args": []
-        }
+        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}
+                {"instType": "USDT-FUTURES", "channel": channel, "instId": symbol}
             )
 
         self.client.ws_connect(
             self.ws_url,
             send_json=submsg,
-            hdlr_json=self.store.onmessage
-        )
+            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/broker/models/bitget.py

@@ -16,13 +16,18 @@ class Detail(DataStore):
     _KEYS = ["symbol"]
 
     def _transform(self, entry: dict[str, Any]) -> dict[str, Any] | None:
-        
-        step_size = entry.get('volume_place', 1)
-        tick_size = entry.get('price_place', 1)
-        step_size = place_to_step(step_size)
-        tick_size = place_to_step(tick_size)
-        entry['tickSize'] = tick_size
-        entry['stepSize'] = step_size
+        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:
@@ -280,4 +285,75 @@ class BitgetDataStore(BitgetV2DataStore):
                 }
             ]
         """
-        return self._get("book")
+        return self._get("book")
+    
+    @property
+    def account(self) -> DataStore:
+        """
+        _KEYS = ["instType", "marginCoin"]
+
+        Data Structure:
+
+        .. code:: json
+
+           [
+                {
+                    "marginCoin": "USDT",
+                    "frozen": "0.00000000",
+                    "available": "13.98545761",
+                    "maxOpenPosAvailable": "13.98545761",
+                    "maxTransferOut": "13.98545761",
+                    "equity": "13.98545761",
+                    "usdtEquity": "13.985457617660",
+                    "crossedRiskRate": "0",
+                    "unrealizedPL": "0.000000000000",
+                    "unionTotalMargin": "100",
+                    "unionAvailable": "20",
+                    "unionMm": "15",
+                    "assetMode": "union"
+                }
+            ]
+        """
+        return self._get("account")
+
+    @property
+    def position(self) -> DataStore:
+        """
+        _KEYS = ["instType", "instId", "posId"]
+
+        Data Structure:
+
+        .. code:: json
+
+           [
+                {
+                    "posId": "1",
+                    "instId": "ETHUSDT",
+                    "marginCoin": "USDT",
+                    "marginSize": "9.5",
+                    "marginMode": "crossed",
+                    "holdSide": "short",
+                    "posMode": "hedge_mode",
+                    "total": "0.1",
+                    "available": "0.1",
+                    "frozen": "0",
+                    "openPriceAvg": "1900",
+                    "leverage": 20,
+                    "achievedProfits": "0",
+                    "unrealizedPL": "0",
+                    "unrealizedPLR": "0",
+                    "liquidationPrice": "5788.108475905242",
+                    "keepMarginRate": "0.005",
+                    "marginRate": "0.004416374196",
+                    "cTime": "1695649246169",
+                    "breakEvenPrice": "24778.97",
+                    "totalFee": "1.45",
+                    "deductedFee": "0.388",
+                    "markPrice": "2500",
+                    "assetMode": "union",
+                    "uTime": "1695711602568",
+                    "autoMargin": "off"
+                }
+            ]
+        """
+        return self._get("position")

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"),

{hyperquant-0.71.dist-info → hyperquant-0.73.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.71
+Version: 0.73
 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.71.dist-info → hyperquant-0.73.dist-info}/RECORD

@@ -5,7 +5,7 @@ hyperquant/draw.py,sha256=up_lQ3pHeVLoNOyh9vPjgNwjD0M-6_IetSGviQUgjhY,54624
 hyperquant/logkit.py,sha256=nUo7nx5eONvK39GOhWwS41zNRL756P2J7-5xGzwXnTY,8462
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
 hyperquant/broker/auth.py,sha256=Wst7mTBuUS2BQ5hZd0a8FNNs5Uc01ac9WzJpseTuyAY,7673
-hyperquant/broker/bitget.py,sha256=G13WRACqxuHfxNh0nKB-11VF02XDsgb0vM1g19eOo2A,2861
+hyperquant/broker/bitget.py,sha256=PEzULGJJQeQ91TKa4F56WhEpcnUHC3WpIx1pi5UXpVQ,9182
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
 hyperquant/broker/lbank.py,sha256=dZUbi0a_Vhkp4pJ1V11X6nEM7I4HhQIVRgpSMeGcAMU,11681
@@ -15,15 +15,15 @@ hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQ
 hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb84D8,8296
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
 hyperquant/broker/lib/util.py,sha256=iMU1qF0CHj5zzlIMEQGwjz-qtEVosEe7slXOCuB7Rcw,566
-hyperquant/broker/models/bitget.py,sha256=swKYa7-jRoCSQxg0AUTZ7lPEhD1vxYIKm49eaIPwMxU,8961
+hyperquant/broker/models/bitget.py,sha256=0RwDY75KrJb-c-oYoMxbqxWfsILe-n_Npojz4UFUq7c,11389
 hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
-hyperquant/broker/models/lbank.py,sha256=ZCD1dOUMyWPT8lKDj6C6LcHEof2d0JN384McURzLA-s,18868
+hyperquant/broker/models/lbank.py,sha256=_ztqhYGDqEHpmSITfYp_cpEJiJrhfJ9dwZ52K_PhE2A,18969
 hyperquant/broker/models/ourbit.py,sha256=xMcbuCEXd3XOpPBq0RYF2zpTFNnxPtuNJZCexMZVZ1k,41965
 hyperquant/datavison/_util.py,sha256=92qk4vO856RqycO0YqEIHJlEg-W9XKapDVqAMxe6rbw,533
 hyperquant/datavison/binance.py,sha256=3yNKTqvt_vUQcxzeX4ocMsI5k6Q6gLZrvgXxAEad6Kc,5001
 hyperquant/datavison/coinglass.py,sha256=PEjdjISP9QUKD_xzXNzhJ9WFDTlkBrRQlVL-5pxD5mo,10482
 hyperquant/datavison/okx.py,sha256=yg8WrdQ7wgWHNAInIgsWPM47N3Wkfr253169IPAycAY,6898
-hyperquant-0.71.dist-info/METADATA,sha256=ldQcPawGZVC-9RTCaAFt4lE5SAw26fPVjbEfjk04xLE,4317
-hyperquant-0.71.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.71.dist-info/RECORD,,
+hyperquant-0.73.dist-info/METADATA,sha256=nAkYdNGtpPFIhgtTm1JWCQCK46kJyAv2EdLrcfTh1nU,4317
+hyperquant-0.73.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.73.dist-info/RECORD,,