hyperquant 1.22__py3-none-any.whl → 1.25__py3-none-any.whl

hyperquant/broker/models/lighter.py

@@ -220,6 +220,62 @@ class Orders(DataStore):
         if items:
             self._insert(items)
 
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        """Handle websocket incremental updates for orders.
+
+        For WS updates we should not clear-and-reinsert. Instead:
+        - For fully filled or cancelled orders => delete
+        - Otherwise => update/insert
+        """
+        if not isinstance(msg, dict):
+            return
+
+        orders_obj = msg.get("orders")
+        if orders_obj is None:
+            account = msg.get("account")
+            if isinstance(account, dict):
+                orders_obj = account.get("orders")
+        if not orders_obj:
+            return
+
+        # Normalize orders to a flat list of dicts
+        if isinstance(orders_obj, dict):
+            raw_list: list[dict[str, Any]] = []
+            for _, lst in orders_obj.items():
+                if isinstance(lst, list):
+                    raw_list.extend([o for o in lst if isinstance(o, dict)])
+        elif isinstance(orders_obj, list):
+            raw_list = [o for o in orders_obj if isinstance(o, dict)]
+        else:
+            return
+
+        def _is_terminal(order: dict[str, Any]) -> bool:
+            status = str(order.get("status", "")).lower()
+            if status in {"cancelled", "canceled", "executed", "filled", "closed", "done"}:
+                return True
+            rem = order.get("remaining_base_amount")
+            try:
+                return float(rem) <= 0 if rem is not None else False
+            except Exception:
+                return False
+
+
+        for entry in raw_list:
+            normalized = self._normalize(entry)
+            if normalized is None:
+                continue
+            # enrich with symbol if mapping is available
+            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:
+                        normalized["symbol"] = symbol
+
+            self._update([normalized])
+            if _is_terminal(entry):
+                self._delete([normalized])
+
 
 
 
@@ -324,6 +380,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 +665,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 +688,11 @@ class LighterDataStore(DataStoreCollection):
             elif msg_type in {"subscribed/account_all", "update/account_all"}:
                 self.accounts._on_message(msg)
                 self.positions._on_message(msg)
+                self.orders._on_message(msg)
+            elif msg_type in {"subscribed/account_all_orders", "update/account_all_orders"}:
+                self.orders._on_message(msg)
+            elif msg_type in {"subscribed/trade", "update/trade"}:
+                self.klines._on_message(msg)
 
 
     @property
@@ -506,3 +845,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.22.dist-info → hyperquant-1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.22
+Version: 1.25
 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,15 +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: numba>=0.62.1
 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.22.dist-info → hyperquant-1.25.dist-info}/RECORD

@@ -7,31 +7,29 @@ hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
 hyperquant/broker/auth.py,sha256=3Ws_2iaF2NTCVIbkLzL_0ae3y7f4vgj9zmozvGaUXnk,16029
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
 hyperquant/broker/bitmart.py,sha256=7j_8TU3Dxjj5HCNX7CbSO3nPZcQH1t31A9UOv5tTbg0,25974
-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/lighter.py,sha256=YuMR6pCWhJjZ2tGMbYanATvbV6t1J22-pyHqO1GNr2g,25639
 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=O9RnU-XBeR9SzicG15jzuzK5oy2kMrRJAyZSqC8DXUw,21938
-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/lighter.py,sha256=I6hjM0of8NLtjSmI6OlbJlvpYDDswLn9yyQLz0I1Mes,30495
 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.22.dist-info/METADATA,sha256=dH0APcdAjkH7pyeQiyPyTd3tl1E2tQVYxMd5YlbzjrE,4438
-hyperquant-1.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-1.22.dist-info/RECORD,,
+hyperquant-1.25.dist-info/METADATA,sha256=oR0A52JvaP4b2W20fQgZpZaoVGaTjtACFMgyQhNB0W0,4345
+hyperquant-1.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-1.25.dist-info/RECORD,,