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

hyperquant/broker/lighter.py

@@ -9,6 +9,7 @@ import pybotters
 
 from lighter.api.account_api import AccountApi
 from lighter.api.order_api import OrderApi
+from lighter.api.candlestick_api import CandlestickApi
 from lighter.api_client import ApiClient
 from lighter.configuration import Configuration
 from lighter.signer_client import SignerClient
@@ -31,6 +32,7 @@ class Lighter:
         api_key_index: int = 3,
         api_client: ApiClient | None = None,
         order_api: OrderApi | None = None,
+        candlestick_api: CandlestickApi | None = None,
         account_api: AccountApi | None = None,
         ws_url: str | None = None,
     ) -> None:
@@ -46,6 +48,7 @@ class Lighter:
         self._owns_api_client = api_client is None
 
         self.order_api = order_api or OrderApi(self._api_client)
+        self.candlestick_api = candlestick_api or CandlestickApi(self._api_client)
         self.account_api = account_api or AccountApi(self._api_client)
         self.signer: SignerClient = None
 
@@ -150,7 +153,9 @@ class Lighter:
 
 
         if include_detail:
-            tasks.append(("detail", self.order_api.order_books()))
+            # Use raw HTTP to avoid strict SDK model validation issues (e.g., status 'inactive').
+            url = f"{self.configuration.host.rstrip('/')}/api/v1/orderBooks"
+            tasks.append(("detail", self.client.get(url)))
 
         if include_orders:
             if account_index is None or symbol is None:
@@ -206,7 +211,12 @@ class Lighter:
         results: dict[str, Any] = {}
         for key, coroutine in tasks:
             try:
-                results[key] = await coroutine
+                resp = await coroutine
+                if key == "detail":
+                    # Parse JSON body for detail endpoint
+                    results[key] = await resp.json()
+                else:
+                    results[key] = resp
             except Exception:
                 logger.exception("Lighter REST request %s failed", key)
                 raise
@@ -300,6 +310,71 @@ class Lighter:
 
         return await self.sub_orderbook(market_ids=[], account_ids=account_ids)
 
+    async def sub_kline(
+        self,
+        symbols: Sequence[str] | str,
+        *,
+        resolutions: Sequence[str] | str,
+    ) -> pybotters.ws.WebSocketApp:
+        """Subscribe to trade streams and aggregate into klines in the store.
+
+        - symbols: list of symbols (e.g., ["BTC-USD"]) or a single symbol; may also be numeric market_ids.
+        - resolutions: list like ["1m", "5m"] or a single resolution; added to kline store for aggregation.
+        """
+
+        # Normalize inputs
+        symbol_list = [symbols] if isinstance(symbols, str) else list(symbols)
+        res_list = [resolutions] if isinstance(resolutions, str) else list(resolutions)
+
+        if not symbol_list:
+            raise ValueError("At least one symbol must be provided")
+        if not res_list:
+            raise ValueError("At least one resolution must be provided")
+
+        # Ensure market metadata for symbol->market_id resolution
+        needs_detail = any(self.get_contract_id(sym) is None and not str(sym).isdigit() for sym in symbol_list)
+        if needs_detail:
+            try:
+                await self.update("detail")
+            except Exception:
+                logger.exception("Failed to refresh Lighter market metadata for kline subscription")
+                raise
+
+        # Resolve market ids and populate id->symbol mapping for klines store
+        trade_market_ids: list[str] = []
+        for sym in symbol_list:
+            market_id = self.get_contract_id(sym)
+            if market_id is None:
+                if str(sym).isdigit():
+                    market_id = str(sym)
+                    symbol_for_map = str(sym)
+                else:
+                    raise ValueError(f"Unknown symbol: {sym}")
+            else:
+                symbol_for_map = sym
+            market_id_str = str(market_id)
+            trade_market_ids.append(market_id_str)
+            # ensure klines store can resolve symbol from market id
+            self.store.klines.id_to_symbol[market_id_str] = symbol_for_map
+
+        # Register resolutions into kline store aggregation list
+        for r in res_list:
+            if r not in self.store.klines._res_list:
+                self.store.klines._res_list.append(r)
+
+        # Build subscribe payload for trade channels
+        channels = [f"trade/{mid}" for mid in trade_market_ids]
+        send_payload = [{"type": "subscribe", "channel": ch} for ch in channels]
+
+        ws_app = self.client.ws_connect(
+            self.ws_url,
+            send_json=send_payload,
+            hdlr_json=self.store.onmessage,
+        )
+
+        await ws_app._event.wait()
+        return ws_app
+
     async def place_order(
         self,
         symbol: str,
@@ -468,3 +543,60 @@ class Lighter:
             "request": request_payload,
             "response": response_payload,
         }
+
+    async def update_kline(
+        self,
+        symbol: str,
+        *,
+        resolution: str,
+        start_timestamp: int,
+        end_timestamp: int,
+        count_back: int,
+        set_timestamp_to_end: bool | None = None,
+    ) -> list[dict[str, Any]]:
+        """Fetch candlesticks and update the Kline store.
+
+        Parameters
+        - symbol: market symbol, e.g. "BTC-USD".
+        - resolution: e.g. "1m", "5m", "1h".
+        - start_timestamp: epoch milliseconds.
+        - end_timestamp: epoch milliseconds.
+        - count_back: number of bars to fetch.
+        - set_timestamp_to_end: if True, API sets last bar timestamp to the end.
+        """
+
+        market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            # try to refresh metadata once
+            await self.update("detail")
+            market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            raise ValueError(f"Unknown symbol: {symbol}")
+
+        resp = await self.candlestick_api.candlesticks(
+            market_id=int(market_id),
+            resolution=resolution,
+            start_timestamp=int(start_timestamp),
+            end_timestamp=int(end_timestamp),
+            count_back=int(count_back),
+            set_timestamp_to_end=bool(set_timestamp_to_end) if set_timestamp_to_end is not None else None,
+        )
+
+        # Update store
+        self.store.klines._onresponse(resp, symbol=symbol, resolution=resolution)
+
+        payload = _maybe_to_dict(resp) or {}
+        items = payload.get("candlesticks") or []
+        # attach symbol/resolution to return
+        out: list[dict[str, Any]] = []
+        for it in items:
+            if hasattr(it, "to_dict"):
+                d = it.to_dict()
+            elif hasattr(it, "model_dump"):
+                d = it.model_dump()
+            else:
+                d = dict(it) if isinstance(it, dict) else {"value": it}
+            d["symbol"] = symbol
+            d["resolution"] = resolution
+            out.append(d)
+        return out

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.22.dist-info → hyperquant-1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.22
+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,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: 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.22.dist-info → hyperquant-1.24.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=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=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=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.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.24.dist-info/METADATA,sha256=B2YHKuabMfGfMSx-OVQnCphVOPL5K94nuG5m5PENKAs,4352
+hyperquant-1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-1.24.dist-info/RECORD,,