hyperquant 0.93__py3-none-any.whl → 0.95__py3-none-any.whl

hyperquant/broker/models/lighter.py

@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Sequence
+
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+def _maybe_to_dict(payload: Any) -> Any:
+    """Convert pydantic models to dict, keeping plain dict/list untouched."""
+    if payload is None:
+        return None
+    if hasattr(payload, "to_dict"):
+        return payload.to_dict()
+    if hasattr(payload, "model_dump"):
+        return payload.model_dump()
+    return payload
+
+
+class Book(DataStore):
+    """Order book snapshots sourced from Lighter websocket feeds."""
+
+    _KEYS = ["s", "S", "p"]
+
+    def _init(self) -> None:
+        self.limit: int | None = None
+        self.id_to_symbol: dict[str, str] = {} # broker设置
+        self._last_update: float = 0.0
+        self._state: dict[str, dict[str, dict[float, float]]] = {}
+        self._visible: dict[str, dict[str, dict[float, dict[str, Any]]]] = {}
+
+    @staticmethod
+    def _market_id_from_channel(channel: str | None) -> str | None:
+        if not channel:
+            return None
+        if ":" in channel:
+            return channel.split(":", 1)[1]
+        if "/" in channel:
+            return channel.split("/", 1)[1]
+        return channel
+
+
+    @staticmethod
+    def _make_entry(symbol: str, side: Literal["a", "b"], price: float, size: float) -> dict[str, Any]:
+        return {
+            "s": symbol,
+            "S": side,
+            "p": f"{price}",
+            "q": f"{abs(size)}",
+        }
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        msg_type = msg.get("type")
+        if msg_type not in {"subscribed/order_book", "update/order_book"}:
+            return
+
+        market_id = self._market_id_from_channel(msg.get("channel"))
+        if market_id is None:
+            return
+
+        order_book = msg.get("order_book")
+        if not isinstance(order_book, dict):
+            return
+
+        state = self._state.setdefault(market_id, {"ask": {}, "bid": {}})
+        visible = self._visible.setdefault(market_id, {"a": {}, "b": {}})
+
+        symbol = self.id_to_symbol.get(market_id)
+        if symbol is None:
+            symbol = market_id
+
+        for side_name, updates_data in (("ask", order_book.get("asks")), ("bid", order_book.get("bids"))):
+            side_state = state[side_name]
+            if not updates_data:
+                continue
+            for level in updates_data:
+                price = level.get("price")
+                size = level.get("size") or level.get("remaining_base_amount") or level.get("base_amount")
+                if price is None or size is None:
+                    continue
+                try:
+                    price_val = float(price)
+                    size_val = float(size)
+                except (TypeError, ValueError):
+                    continue
+                if size_val <= 0:
+                    side_state.pop(price_val, None)
+                else:
+                    side_state[price_val] = size_val
+
+        def build_visible(side_name: Literal["ask", "bid"]) -> dict[float, dict[str, Any]]:
+            side_state = state[side_name]
+            reverse = side_name == "bid"
+            sorted_levels = sorted(side_state.items(), reverse=reverse)
+            if self.limit is not None:
+                sorted_levels = sorted_levels[: self.limit]
+            entry_side = "a" if side_name == "ask" else "b"
+            return {
+                price: self._make_entry(symbol, entry_side, price, size)
+                for price, size in sorted_levels
+            }
+
+        new_visible = {
+            "a": build_visible("ask"),
+            "b": build_visible("bid"),
+        }
+
+        removals: list[dict[str, Any]] = []
+        updates: list[dict[str, Any]] = []
+
+        for side_key in ("a", "b"):
+            prev_side = visible[side_key]
+            next_side = new_visible[side_key]
+
+            for price, entry in prev_side.items():
+                if price not in next_side:
+                    removals.append({k: entry[k] for k in self._KEYS})
+
+            for price, entry in next_side.items():
+                prev_entry = prev_side.get(price)
+                if prev_entry is None or prev_entry.get("q") != entry.get("q"):
+                    updates.append(entry)
+
+        if removals:
+            self._delete(removals)
+        if updates:
+            self._update(updates)
+
+        self._visible[market_id] = new_visible
+        self._last_update = time.time()
+
+    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 last_update(self) -> float:
+        return self._last_update
+
+
+
+
+class Detail(DataStore):
+    """Market metadata."""
+
+    _KEYS = ["symbol"]
+
+    def _onresponse(self, data: Any) -> None:
+        payload = _maybe_to_dict(data) or {}
+        order_books = payload.get("order_books") or payload.get("order_book_details") or []
+
+        if isinstance(order_books, dict):
+            order_books = list(order_books.values())
+
+        normalized: list[dict[str, Any]] = []
+        for entry in order_books or []:
+            if not isinstance(entry, dict):
+                continue
+            market_id = entry.get("market_id") or entry.get("id")
+            symbol = entry.get("symbol")
+            if market_id is None and symbol is None:
+                continue
+            record = dict(entry)
+            if market_id is None and symbol is not None:
+                record["market_id"] = symbol
+            normalized.append(record)
+
+        self._clear()
+        if normalized:
+            self._insert(normalized)
+
+
+class Orders(DataStore):
+    """Active orders."""
+
+    _KEYS = ["order_id"]
+
+    def _init(self) -> None:
+        self.id_to_symbol: dict[str, str] = {}  # broker设置
+
+    @staticmethod
+    def _normalize(entry: dict[str, Any]) -> dict[str, Any] | None:
+        order_id = entry.get("order_id") or entry.get("orderId")
+        if order_id is None:
+            return None
+        normalized = dict(entry)
+        normalized["order_id"] = str(order_id)
+        return normalized
+
+    def _onresponse(self, data: Any) -> None:
+        payload = _maybe_to_dict(data) or {}
+        orders = payload.get("orders") or []
+        items: list[dict[str, Any]] = []
+        for entry in orders:
+            if not isinstance(entry, dict):
+                continue
+            normalized = self._normalize(entry)
+            if self.id_to_symbol:
+                market_id = entry.get("market_index")
+                if market_id is not None:
+                    symbol = self.id_to_symbol.get(str(market_id))
+                    if symbol is not None and normalized is not None:
+                        normalized["symbol"] = symbol
+
+            if normalized:
+                items.append(normalized)
+                
+        self._clear()
+        if items:
+            self._insert(items)
+
+
+
+
+
+class Accounts(DataStore):
+    """Account level balances and metadata."""
+
+    _KEYS = ["account_index"]
+
+    def _normalize_account(self, entry: dict[str, Any]) -> dict[str, Any] | None:
+        account_index = entry.get("account_index") or entry.get("index")
+        if account_index is None:
+            return None
+        normalized = dict(entry)
+        normalized["account_index"] = account_index
+        normalized.pop("positions", None)
+        return normalized
+
+    def _on_accounts(self, accounts: Iterable[dict[str, Any]]) -> None:
+        normalized: list[dict[str, Any]] = []
+        for account in accounts:
+            if not isinstance(account, dict):
+                continue
+            record = self._normalize_account(account)
+            if record:
+                normalized.append(record)
+        if not normalized:
+            return
+        keys = [{"account_index": record["account_index"]} for record in normalized]
+        self._delete(keys)
+        self._insert(normalized)
+
+    def _onresponse(self, data: Any) -> None:
+        payload = _maybe_to_dict(data) or {}
+        accounts = payload.get("accounts") or []
+        self._on_accounts(accounts)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        account = msg.get("account")
+        if not isinstance(account, dict):
+            return
+        self._on_accounts([account])
+
+
+class Positions(DataStore):
+    """Per-market positions grouped by account."""
+
+    _KEYS = ["account_index", "market_id"]
+
+    def _init(self) -> None:
+        self.id_to_symbol: dict[str, str] = {}  # broker设置
+
+    @staticmethod
+    def _normalize(
+        account_index: Any,
+        position: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        market_id = position.get("market_id")
+        if account_index is None or market_id is None:
+            return None
+        normalized = dict(position)
+        normalized["account_index"] = account_index
+        normalized["market_id"] = market_id
+        return normalized
+
+    def _update_positions(
+        self,
+        account_index: Any,
+        positions: Sequence[dict[str, Any]] | None,
+    ) -> None:
+        if positions is None:
+            return
+        items: list[dict[str, Any]] = []
+        for position in positions:
+            if not isinstance(position, dict):
+                continue
+            record = self._normalize(account_index, position)
+            if record:
+                items.append(record)
+        if not items:
+            return
+        keys = [{"account_index": item["account_index"], "market_id": item["market_id"]} for item in items]
+        self._delete(keys)
+        self._insert(items)
+
+    def _onresponse(self, data: Any) -> None:
+        payload = _maybe_to_dict(data) or {}
+        accounts = payload.get("accounts") or []
+        for account in accounts:
+            if not isinstance(account, dict):
+                continue
+            account_index = account.get("account_index") or account.get("index")
+            positions = account.get("positions")
+            self._update_positions(account_index, positions)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        account = msg.get("account")
+        if not isinstance(account, dict):
+            return
+        account_index = account.get("account_index") or account.get("index")
+        positions = account.get("positions")
+        self._update_positions(account_index, positions)
+
+
+class LighterDataStore(DataStoreCollection):
+    """Data store collection for the Lighter exchange."""
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._create("orders", datastore_class=Orders)
+        self._create("accounts", datastore_class=Accounts)
+        self._create("positions", datastore_class=Positions)
+
+    def set_id_to_symbol(self, id_to_symbol: dict[str, str]) -> None:
+        self.id_to_symbol = id_to_symbol
+        self.book.id_to_symbol = self.id_to_symbol
+        self.orders.id_to_symbol = self.id_to_symbol
+        self.positions.id_to_symbol = self.id_to_symbol
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+
+        msg_type = msg.get("type")
+        if msg_type == "ping":
+            asyncio.create_task(ws.send_json({"type": "pong"}))
+            return
+        
+        if isinstance(msg, dict):
+            msg_type = msg.get("type")
+            if msg_type in {"subscribed/order_book", "update/order_book"}:
+                self.book._on_message(msg)
+            elif msg_type in {"subscribed/account_all", "update/account_all"}:
+                self.accounts._on_message(msg)
+                self.positions._on_message(msg)
+
+
+    @property
+    def book(self) -> Book:
+        """
+        Lighter 深度快照。
+
+        .. code:: json
+
+            {
+                "s": "BTC-USD",
+                "S": "a",  # \"a\"=ask / \"b\"=bid
+                "p": "50250.5",
+                "q": "0.37"
+            }
+        """
+        return self._get("book")
+
+    @property
+    def detail(self) -> Detail:
+        """
+        `lighter.models.OrderBookDetail` 元数据。
+
+        .. code:: json
+
+            [
+                {
+                    "symbol": "DOLO",
+                    "market_id": 75,
+                    "status": "active",
+                    "taker_fee": "0.0000",
+                    "maker_fee": "0.0000",
+                    "liquidation_fee": "1.0000",
+                    "min_base_amount": "30.0",
+                    "min_quote_amount": "10.000000",
+                    "supported_size_decimals": 1,
+                    "supported_price_decimals": 5,
+                    "supported_quote_decimals": 6,
+                    "order_quote_limit": ""
+                }
+            ]
+        """
+        return self._get("detail")
+
+    @property
+    def orders(self) -> Orders:
+        """
+        活动订单（`lighter.models.Order`）。
+
+        .. code:: json
+
+            {
+                "order_index": 21673573193817727,
+                "client_order_index": 0,
+                "order_id": "21673573193817727",
+                "client_order_id": "0",
+                "market_index": 75,
+                "symbol": "DOLO",
+                "owner_account_index": 311464,
+                "initial_base_amount": "146.7",
+                "price": "0.07500",
+                "nonce": 281474963807871,
+                "remaining_base_amount": "146.7",
+                "is_ask": false,
+                "base_size": 1467,
+                "base_price": 7500,
+                "filled_base_amount": "0.0",
+                "filled_quote_amount": "0.000000",
+                "side": "",
+                "type": "limit",
+                "time_in_force": "good-till-time",
+                "reduce_only": false,
+                "trigger_price": "0.00000",
+                "order_expiry": 1764082202799,
+                "status": "open",
+                "trigger_status": "na",
+                "trigger_time": 0,
+                "parent_order_index": 0,
+                "parent_order_id": "0",
+                "to_trigger_order_id_0": "0",
+                "to_trigger_order_id_1": "0",
+                "to_cancel_order_id_0": "0",
+                "block_height": 75734444,
+                "timestamp": 1761663003,
+                "created_at": 1761663003,
+                "updated_at": 1761663003
+            }
+        """
+        return self._get("orders")
+
+
+    @property
+    def accounts(self) -> Accounts:
+        """
+        账户概览（`lighter.models.DetailedAccount`）。
+
+        .. code:: json
+            [
+                {
+                    "code": 0,
+                    "account_type": 0,
+                    "index": 311464,
+                    "l1_address": "0x5B3f0AdDfaf4c1d8729e266b22093545EFaE6c0e",
+                    "cancel_all_time": 0,
+                    "total_order_count": 1,
+                    "total_isolated_order_count": 0,
+                    "pending_order_count": 0,
+                    "available_balance": "30.000000",
+                    "status": 0,
+                    "collateral": "30.000000",
+                    "account_index": 311464,
+                    "name": "",
+                    "description": "",
+                    "can_invite": false,
+                    "referral_points_percentage": "",
+                    "total_asset_value": "30",
+                    "cross_asset_value": "30",
+                    "shares": []
+                }
+            ]
+        """
+        return self._get("accounts")
+
+    @property
+    def positions(self) -> Positions:
+        """
+        账户持仓（`lighter.models.AccountPosition`）。
+
+        .. code:: json
+
+        [
+            {
+                "market_id": 75,
+                "symbol": "DOLO",
+                "initial_margin_fraction": "33.33",
+                "open_order_count": 1,
+                "pending_order_count": 0,
+                "position_tied_order_count": 0,
+                "sign": 1,
+                "position": "129.8",
+                "avg_entry_price": "0.08476",
+                "position_value": "10.969398",
+                "unrealized_pnl": "-0.032450",
+                "realized_pnl": "0.000000",
+                "liquidation_price": "0",
+                "margin_mode": 0,
+                "allocated_margin": "0.000000",
+                "account_index": 311464
+            }
+        ]
+        """
+        return self._get("positions")

{hyperquant-0.93.dist-info → hyperquant-0.95.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.93
+Version: 0.95
 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
@@ -18,6 +18,7 @@ Requires-Dist: colorama>=0.4.6
 Requires-Dist: cryptography>=44.0.2
 Requires-Dist: curl-cffi>=0.13.0
 Requires-Dist: duckdb>=1.2.2
+Requires-Dist: lighter-sdk
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1

{hyperquant-0.93.dist-info → hyperquant-0.95.dist-info}/RECORD

@@ -4,13 +4,15 @@ hyperquant/db.py,sha256=i2TjkCbmH4Uxo7UTDvOYBfy973gLcGexdzuT_YcSeIE,6678
 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=xNZEQP0LRRV9BkT2uXBJ-vFfeahUnRVq1bjIT6YbQu8,10089
+hyperquant/broker/auth.py,sha256=C8B5-x8Qcaeafm4ZwPCVFR7GRURmHC3CE4_vdg00Qgw,12139
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
+hyperquant/broker/bitmart.py,sha256=3lAkSy8J2p-M-663cUVFuRU-XtgNEwWAa4SKgeG6Vb8,16798
 hyperquant/broker/coinup.py,sha256=eOr8BTRXiTb5tCU2FDmvBdXXgqiwVmCbP5pdeA1ORJ8,20390
 hyperquant/broker/coinw.py,sha256=SnJU0vASh77rfcpMGWaIfTblQSjQk3vjlW_4juYdbcs,17214
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
 hyperquant/broker/lbank.py,sha256=98M5wmSoeHwbBYMA3rh25zqLb6fQKVaEmwqALF5nOvY,22181
+hyperquant/broker/lighter.py,sha256=lW4LgEJHqbiUZPu2BE1aKz_JBIW94KTKnCkD9vuHt-Q,16695
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
 hyperquant/broker/ws.py,sha256=NS71Do-62mtVrGcyNE-AtHJkDecsSxdz_KU1yNBr_BQ,4079
 hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQJKcmyk,95785
@@ -18,16 +20,18 @@ hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb8
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
 hyperquant/broker/lib/util.py,sha256=iMU1qF0CHj5zzlIMEQGwjz-qtEVosEe7slXOCuB7Rcw,566
 hyperquant/broker/models/bitget.py,sha256=0RwDY75KrJb-c-oYoMxbqxWfsILe-n_Npojz4UFUq7c,11389
+hyperquant/broker/models/bitmart.py,sha256=Utu67H0D1wzppKeHqZmsPLeJ0sao2-yR_iGwWP5p0wU,20800
 hyperquant/broker/models/coinup.py,sha256=X_ngB2_sgTOdfAZqTyeWvCN03j-0_inZ6ugZKW6hR7k,11173
 hyperquant/broker/models/coinw.py,sha256=LvLMVP7i-qkkTK1ubw8eBkMK2RQmFoKPxdKqmC4IToY,22157
 hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
 hyperquant/broker/models/lbank.py,sha256=vHkNKxIMzpoC_EwcZnEOPOupizF92yGWi9GKxvYYFUQ,19181
+hyperquant/broker/models/lighter.py,sha256=RpqyMPrXbs4_OY9WSDep4T8pDhxDGaFQ8vdVmLZnfBg,16732
 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.93.dist-info/METADATA,sha256=L9HIZUQL-xV3tZTqgvHD9p1Vin2e7M-XPuimVVmt3F8,4382
-hyperquant-0.93.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.93.dist-info/RECORD,,
+hyperquant-0.95.dist-info/METADATA,sha256=VCnz-XozwQFVbD3iQCz_Xg1kmKFOSqLCqyQwmeIq_iU,4409
+hyperquant-0.95.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.95.dist-info/RECORD,,