hyperquant 1.21__py3-none-any.whl → 1.24__py3-none-any.whl

hyperquant/broker/models/bitmart.py

@@ -98,29 +98,11 @@ class Book(DataStore):
         self._last_update = ms_t
     
     def _on_message_api(self, msg: dict[str, Any]) -> None:
-        # {
-        #     "data": {
-        #         "symbol": "BTCUSDT",
-        #         "asks": [
-        #             {
-        #                 "price": "70294.4",
-        #                 "vol": "455"
-        #             }
-        #         ],
-        #         "bids": [
-        #             {
-        #                 "price": "70293.9",
-        #                 "vol": "1856"
-        #             }
-        #         ],
-        #         "ms_t": 1730399750402
-        #     },
-        #     "group": "futures/depthAll20:BTCUSDT@200ms"
-        # }
         data = msg.get("data")
         if not isinstance(data, dict):
             return
-        symbol = data.get("symbol")
+        # Some callers embed symbol at top-level; prefer msg["symbol"] when present
+        symbol = msg.get("symbol") or data.get("symbol")
         asks = data.get("asks") or []
         bids = data.get("bids") or []
         if self.limit:
@@ -128,12 +110,19 @@ class Book(DataStore):
             bids = bids[: self.limit]
             
         self._find_and_delete({'s': symbol})
+        # OpenAPI order book arrays are typically [price, size, timestamp]
+        def _normalize_level(level: Any) -> tuple[str, str]:
+            if isinstance(level, dict):
+                return str(level.get("price", "0")), str(level.get("vol", "0"))
+            if isinstance(level, (list, tuple)) and len(level) >= 2:
+                return str(level[0]), str(level[1])
+            return "0", "0"
+
         self._update([
             self._make_entry(
                 symbol,
                 "a",
-                entry.get("price", '0'),
-                entry.get("vol", '0'),
+                *_normalize_level(entry),
             )
             for entry in asks
         ])
@@ -141,11 +130,11 @@ class Book(DataStore):
             self._make_entry(
                 symbol,
                 "b",
-                entry.get("price", '0'),
-                entry.get("vol", '0'),
+                *_normalize_level(entry),
             )
             for entry in bids
         ])
+    
 
     def sorted(self, query: Item | None = None, limit: int | None = None) -> dict[str, list[Item]]:
         return self._sorted(
@@ -325,7 +314,7 @@ class BitmartDataStore(DataStoreCollection):
         self._create("positions", datastore_class=Positions)
         self._create("balances", datastore_class=Balances)
         self._create("ticker", datastore_class=Ticker)
-
+    
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
         if isinstance(msg, dict):
             group = msg.get("group")

hyperquant/broker/models/lighter.py

@@ -324,6 +324,282 @@ class Positions(DataStore):
         self._update_positions(account_index, positions)
 
 
+class Klines(DataStore):
+    """Candlestick/Kline store keyed by (symbol, resolution, timestamp).
+
+    - Maintains a list of active resolutions in ``_res_list`` (populated by REST updates).
+    - Updates candles in real-time by aggregating trade websocket messages.
+    """
+
+    _KEYS = ["symbol", "resolution", "timestamp"]
+
+    def _init(self) -> None:
+        self.id_to_symbol: dict[str, str] = {}
+        self._current_symbol: str | None = None
+        self._res_list: list[str] = []
+        # Track last processed trade_id to deduplicate snapshot trades after reconnect
+        self._last_trade_id_by_market: dict[str, int] = {}
+        self._last_trade_id_by_symbol: dict[str, int] = {}
+
+    @staticmethod
+    def _resolution_to_ms(resolution: str) -> int | None:
+        try:
+            res = resolution.strip().lower()
+        except Exception:
+            return None
+        # Common forms: 1m, 5m, 1h, 1d; also allow pure digits => seconds
+        unit = res[-1]
+        num_part = res[:-1] if unit in {"s", "m", "h", "d", "w"} else res
+        try:
+            n = int(num_part)
+        except Exception:
+            return None
+        if unit == "s":
+            return n * 1000
+        if unit == "m" or unit not in {"s", "h", "d", "w"}:  # default minutes if no unit
+            return n * 60 * 1000
+        if unit == "h":
+            return n * 60 * 60 * 1000
+        if unit == "d":
+            return n * 24 * 60 * 60 * 1000
+        if unit == "w":
+            return n * 7 * 24 * 60 * 60 * 1000
+        return None
+
+    @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
+
+    def _compose_item(
+        self,
+        *,
+        symbol: str,
+        resolution: str,
+        ts: int,
+        price: float,
+        size: float,
+        last_trade_id: int | None,
+        open_price: float | None = None,
+    ) -> dict[str, Any]:
+        return {
+            "symbol": symbol,
+            "resolution": resolution,
+            "timestamp": ts,
+            "open": price if open_price is None else float(open_price),
+            "high": price,
+            "low": price,
+            "close": price,
+            "volume0": abs(size),
+            "volume1": abs(size) * price,
+            "last_trade_id": last_trade_id or 0,
+        }
+
+    def _ensure_backfill(self, *, symbol: str, resolution: str, new_bucket_ts: int) -> None:
+        """Backfill missing empty bars up to (but not including) new_bucket_ts.
+
+        Uses the last known close as O/H/L/C for synthetic bars and zero volume.
+        """
+        step = self._resolution_to_ms(resolution)
+        if not step:
+            return
+        # find the last existing bar before new_bucket_ts
+        rows = self.find({"symbol": symbol, "resolution": resolution})
+        prev = None
+        prev_ts = None
+        for r in rows:
+            try:
+                ts = int(r.get("timestamp"))
+            except Exception:
+                continue
+            if ts < new_bucket_ts and (prev_ts is None or ts > prev_ts):
+                prev = r
+                prev_ts = ts
+        if prev is None or prev_ts is None:
+            return
+        expected = prev_ts + step
+        while expected < new_bucket_ts:
+            prev_close = float(prev.get("close"))
+            fill_item = {
+                "symbol": symbol,
+                "resolution": resolution,
+                "timestamp": expected,
+                "open": prev_close,
+                "high": prev_close,
+                "low": prev_close,
+                "close": prev_close,
+                "volume0": 0.0,
+                "volume1": 0.0,
+                "last_trade_id": int(prev.get("last_trade_id", 0)) if prev.get("last_trade_id") is not None else 0,
+            }
+            self._insert([fill_item])
+            prev = fill_item
+            expected += step
+
+    def _merge_trade(self, *, symbol: str, trade_ts_ms: int, price: float, size: float, last_trade_id: int | None) -> None:
+        # Iterate active resolutions
+        for res in list(self._res_list):
+            interval_ms = self._resolution_to_ms(res)
+            if not interval_ms:
+                continue
+            bucket_ts = (trade_ts_ms // interval_ms) * interval_ms
+            # Upsert logic
+            existing = self.get({"symbol": symbol, "resolution": res, "timestamp": bucket_ts})
+            if existing is None:
+                # backfill any missing empty bars before creating a new bucket
+                self._ensure_backfill(symbol=symbol, resolution=res, new_bucket_ts=bucket_ts)
+                # open should be previous bar's close if exists; if none, fall back to current price
+                prev = None
+                rows = self.find({"symbol": symbol, "resolution": res})
+                prev_ts = None
+                for r in rows:
+                    try:
+                        ts = int(r.get("timestamp"))
+                    except Exception:
+                        continue
+                    if ts < bucket_ts and (prev_ts is None or ts > prev_ts):
+                        prev = r
+                        prev_ts = ts
+                open_px = float(prev.get("close")) if prev is not None else price
+                self._insert([
+                    self._compose_item(
+                        symbol=symbol,
+                        resolution=res,
+                        ts=bucket_ts,
+                        price=price,
+                        size=size,
+                        last_trade_id=last_trade_id,
+                        open_price=open_px,
+                    )
+                ])
+                continue
+            # merge into existing
+            updated = dict(existing)
+            o = float(updated.get("open", price))
+            h = float(updated.get("high", price))
+            l = float(updated.get("low", price))
+            c = float(updated.get("close", price))
+            v0 = float(updated.get("volume0", 0.0))
+            v1 = float(updated.get("volume1", 0.0))
+            p = float(price)
+            s = abs(float(size))
+            updated["open"] = o
+            updated["high"] = max(h, p)
+            updated["low"] = min(l, p)
+            updated["close"] = p
+            updated["volume0"] = v0 + s
+            updated["volume1"] = v1 + s * p
+            if last_trade_id is not None:
+                try:
+                    updated["last_trade_id"] = max(int(last_trade_id), int(updated.get("last_trade_id", 0)))
+                except Exception:
+                    updated["last_trade_id"] = int(last_trade_id)
+            self._update([updated])
+
+    def _onresponse(self, data: Any, *, symbol: str | None = None, resolution: str | None = None) -> None:
+        payload = _maybe_to_dict(data) or {}
+        candlesticks = payload.get("candlesticks") or []
+        res = payload.get("resolution") or resolution
+        if res not in self._res_list and res is not None:
+            self._res_list.append(res)
+
+        sym = symbol or self._current_symbol
+
+        # Sort incoming bars by timestamp to backfill in order
+        items: list[dict[str, Any]] = []
+        for c in sorted((candlesticks or []), key=lambda x: x.get("timestamp", 0)):
+            if not isinstance(c, dict):
+                continue
+            entry = dict(c)
+            if sym is not None:
+                entry["symbol"] = sym
+            if res is not None:
+                entry["resolution"] = res
+            items.append(entry)
+
+        # Insert or update per bar; backfill gaps before inserting new bars
+        for entry in items:
+            sym_i = entry.get("symbol")
+            res_i = entry.get("resolution")
+            ts_i = entry.get("timestamp")
+            if sym_i is None or res_i is None or ts_i is None:
+                continue
+            if self.get({"symbol": sym_i, "resolution": res_i, "timestamp": ts_i}) is None:
+                self._ensure_backfill(symbol=sym_i, resolution=res_i, new_bucket_ts=int(ts_i))
+                self._insert([entry])
+            else:
+                self._update([entry])
+
+        # Update last_trade_id baseline (by symbol) from REST bars if available
+        if sym is not None:
+            max_tid = 0
+            for e in items:
+                try:
+                    tid = int(e.get("last_trade_id", 0))
+                except Exception:
+                    tid = 0
+                if tid > max_tid:
+                    max_tid = tid
+            if max_tid:
+                prev = self._last_trade_id_by_symbol.get(sym, 0)
+                if max_tid > prev:
+                    self._last_trade_id_by_symbol[sym] = max_tid
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        msg_type = msg.get("type")
+        if msg_type not in {"subscribed/trade", "update/trade"}:
+            return
+        market_id = self._market_id_from_channel(msg.get("channel"))
+        if market_id is None:
+            return
+        market_id_str = str(market_id)
+        symbol = self.id_to_symbol.get(market_id_str) or market_id_str
+        trades = msg.get("trades") or []
+        # Baseline last trade_id from market and symbol
+        base_last_tid = max(
+            self._last_trade_id_by_market.get(market_id_str, 0),
+            self._last_trade_id_by_symbol.get(symbol, 0),
+        )
+        # Process in ascending trade_id order for stability
+        try:
+            trades_sorted = sorted(trades, key=lambda x: int(x.get("trade_id", 0)))
+        except Exception:
+            trades_sorted = trades
+
+        last_tid = base_last_tid
+        for t in trades_sorted:
+            if not isinstance(t, dict):
+                continue
+            ts = t.get("timestamp")
+            price = t.get("price")
+            size = t.get("size")
+            trade_id = t.get("trade_id")
+            try:
+                ts = int(ts)
+                p = float(price)
+                s = float(size)
+                tid = int(trade_id) if trade_id is not None else 0
+            except Exception:
+                continue
+            # Skip stale or duplicate snapshot trades
+            if tid and last_tid and tid <= last_tid:
+                continue
+            self._merge_trade(symbol=symbol, trade_ts_ms=ts, price=p, size=s, last_trade_id=tid)
+            if tid > last_tid:
+                last_tid = tid
+
+        # Persist last processed trade_id for this market
+        if last_tid and last_tid > base_last_tid:
+            self._last_trade_id_by_market[market_id_str] = last_tid
+
+    
+
+
 class LighterDataStore(DataStoreCollection):
     """Data store collection for the Lighter exchange."""
 
@@ -333,12 +609,14 @@ class LighterDataStore(DataStoreCollection):
         self._create("orders", datastore_class=Orders)
         self._create("accounts", datastore_class=Accounts)
         self._create("positions", datastore_class=Positions)
+        self._create("klines", datastore_class=Klines)
 
     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
+        self.klines.id_to_symbol = self.id_to_symbol
 
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
 
@@ -354,6 +632,8 @@ class LighterDataStore(DataStoreCollection):
             elif msg_type in {"subscribed/account_all", "update/account_all"}:
                 self.accounts._on_message(msg)
                 self.positions._on_message(msg)
+            elif msg_type in {"subscribed/trade", "update/trade"}:
+                self.klines._on_message(msg)
 
 
     @property
@@ -506,3 +786,24 @@ class LighterDataStore(DataStoreCollection):
         ]
         """
         return self._get("positions")
+
+    @property
+    def klines(self) -> "Klines":
+        """
+        K线/蜡烛图数据（`lighter.models.Candlesticks` -> `lighter.models.Candlestick`）。
+
+        .. code:: json
+
+            {
+                "symbol": "BTC",
+                "timestamp": 1730612700000,
+                "open": 68970.5,
+                "high": 69012.3,
+                "low": 68890.0,
+                "close": 68995.1,
+                "volume0": 12.34,
+                "volume1": 850000.0,
+                "resolution": "1m"
+            }
+        """
+        return self._get("klines")

hyperquant/broker/ws.py

@@ -37,12 +37,19 @@ class Heartbeat:
         while not ws.closed:
             await ws.send_json({"event": "ping"})
             await asyncio.sleep(3.0)
+    
+    @staticmethod   
+    async def lighter(ws: ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_json({"type":"ping"})
+            await asyncio.sleep(3)
 
 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
 pybotters.ws.HeartbeatHosts.items['ws.futurescw.com'] = Heartbeat.coinw
+pybotters.ws.HeartbeatHosts.items['mainnet.zklighter.elliot.ai'] = Heartbeat.lighter
 
 class WssAuth:
     @staticmethod

{hyperquant-1.21.dist-info → hyperquant-1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.21
+Version: 1.24
 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
@@ -16,14 +16,12 @@ Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.10.4
 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: lighter-sdk>=0.1.4
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1
 Requires-Dist: pyecharts>=2.0.8
-Requires-Dist: rnet==3.0.0rc10
 Description-Content-Type: text/markdown
 
 # minquant

{hyperquant-1.21.dist-info → hyperquant-1.24.dist-info}/RECORD

@@ -4,34 +4,32 @@ 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=C8B5-x8Qcaeafm4ZwPCVFR7GRURmHC3CE4_vdg00Qgw,12139
+hyperquant/broker/auth.py,sha256=3Ws_2iaF2NTCVIbkLzL_0ae3y7f4vgj9zmozvGaUXnk,16029
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
-hyperquant/broker/bitmart.py,sha256=2Yd_Jzn0XYzl3rYN1rmNuwy7Wy74T3bBQ-ue7RvIbMU,22206
-hyperquant/broker/coinup.py,sha256=eOr8BTRXiTb5tCU2FDmvBdXXgqiwVmCbP5pdeA1ORJ8,20390
+hyperquant/broker/bitmart.py,sha256=7j_8TU3Dxjj5HCNX7CbSO3nPZcQH1t31A9UOv5tTbg0,25974
 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/lighter.py,sha256=mgkdHjXXmOAhVlU8uZJ28fcPqzHM0fnjJXXYMTD4wJs,21918
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
-hyperquant/broker/ws.py,sha256=NS71Do-62mtVrGcyNE-AtHJkDecsSxdz_KU1yNBr_BQ,4079
+hyperquant/broker/ws.py,sha256=AzyFAHIDF4exxwm_IAEV6ihftwAlu19al8Vla4ygk-A,4354
 hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQJKcmyk,95785
 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=0RwDY75KrJb-c-oYoMxbqxWfsILe-n_Npojz4UFUq7c,11389
-hyperquant/broker/models/bitmart.py,sha256=hPxSFLmsJif9wm4nTln5G_zCbsoRnM1BF9fnfciZIHo,22061
-hyperquant/broker/models/coinup.py,sha256=X_ngB2_sgTOdfAZqTyeWvCN03j-0_inZ6ugZKW6hR7k,11173
+hyperquant/broker/models/bitmart.py,sha256=O9RnU-XBeR9SzicG15jzuzK5oy2kMrRJAyZSqC8DXUw,21938
 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/lighter.py,sha256=vpo1xm3S_FEV3GOlbN9_qEhrgj8qXM7jP8jstBP2S0Y,28217
 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-1.21.dist-info/METADATA,sha256=1ZJFW9uGSQFzXQTBy74LLbaay4lUmc_pTOzSOugj_nU,4409
-hyperquant-1.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-1.21.dist-info/RECORD,,
+hyperquant-1.24.dist-info/METADATA,sha256=B2YHKuabMfGfMSx-OVQnCphVOPL5K94nuG5m5PENKAs,4352
+hyperquant-1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-1.24.dist-info/RECORD,,