hyperquant 1.61__tar.gz → 1.62__tar.gz

{hyperquant-1.61 → hyperquant-1.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.61
+Version: 1.62
 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-1.61 → hyperquant-1.62}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.61"
+version = "1.62"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.61 → hyperquant-1.62}/src/hyperquant/broker/models/polymarket.py

@@ -635,6 +635,8 @@ class Book(DataStore):
         # Internal hot-path storage:
         # symbol -> {"a": {price_ticks: size_units}, "b": {price_ticks: size_units}}
         self._levels: dict[str, dict[str, dict[int, int]]] = {}
+        # Keep per-level event timestamps so rows can surface Polymarket ws timestamp.
+        self._level_ts: dict[str, dict[str, dict[int, int | None]]] = {}
         # Per-symbol monotonic sequence/timestamp gate.
         self._last_seq: dict[str, int] = {}
 
@@ -767,14 +769,29 @@ class Book(DataStore):
             self._levels[symbol] = state
         return state
 
+    def _symbol_level_ts(self, symbol: str) -> dict[str, dict[int, int | None]]:
+        state = self._level_ts.get(symbol)
+        if state is None:
+            state = {"a": {}, "b": {}}
+            self._level_ts[symbol] = state
+        return state
+
     def _record(
-        self, *, symbol: str, side: str, price_ticks: int, size_units: int, alias: str | None
+        self,
+        *,
+        symbol: str,
+        side: str,
+        price_ticks: int,
+        size_units: int,
+        alias: str | None,
+        event_time_ms: int | None,
     ) -> dict[str, Any]:
         payload: dict[str, Any] = {
             "s": symbol,
             "S": side,
             "p": self._ticks_to_price(price_ticks),
             "q": self._units_to_size(size_units),
+            "event_time_ms": event_time_ms,
         }
         if alias is not None:
             payload["alias"] = alias
@@ -790,8 +807,10 @@ class Book(DataStore):
         side: str,
         entries: Iterable[dict[str, Any]] | None,
         alias: str | None,
+        event_time_ms: int | None,
     ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
         next_levels: dict[int, int] = {}
+        next_timestamps: dict[int, int | None] = {}
         if entries:
             for entry in entries:
                 if not isinstance(entry, dict):
@@ -803,9 +822,12 @@ class Book(DataStore):
                 if size_units <= 0:
                     continue
                 next_levels[price_ticks] = size_units
+                next_timestamps[price_ticks] = event_time_ms
 
         symbol_levels = self._symbol_levels(symbol)
+        symbol_ts = self._symbol_level_ts(symbol)
         prev_levels = symbol_levels[side]
+        prev_ts = symbol_ts[side]
         removals = [
             self._delete_key(symbol=symbol, side=side, price_ticks=price_ticks)
             for price_ticks in prev_levels
@@ -818,11 +840,14 @@ class Book(DataStore):
                 price_ticks=price_ticks,
                 size_units=size_units,
                 alias=alias,
+                event_time_ms=event_time_ms,
             )
             for price_ticks, size_units in next_levels.items()
             if prev_levels.get(price_ticks) != size_units
+            or prev_ts.get(price_ticks) != next_timestamps.get(price_ticks)
         ]
         symbol_levels[side] = next_levels
+        symbol_ts[side] = next_timestamps
         return removals, updates
 
     def _on_message(self, msg: dict[str, Any]) -> None:
@@ -835,19 +860,22 @@ class Book(DataStore):
             symbol, alias = self._alias(asset_id)
             if symbol is None:
                 return
-            if not self._accept_sequence(symbol, self._extract_timestamp(msg)):
+            event_time_ms = self._extract_timestamp(msg)
+            if not self._accept_sequence(symbol, event_time_ms):
                 return
             bid_deletes, bid_updates = self._snapshot_side(
                 symbol=symbol,
                 side="b",
                 entries=msg.get("bids"),
                 alias=alias,
+                event_time_ms=event_time_ms,
             )
             ask_deletes, ask_updates = self._snapshot_side(
                 symbol=symbol,
                 side="a",
                 entries=msg.get("asks"),
                 alias=alias,
+                event_time_ms=event_time_ms,
             )
 
             deletes = bid_deletes + ask_deletes
@@ -884,6 +912,7 @@ class Book(DataStore):
                 continue
             alias = bucket["alias"]
             symbol_levels = self._symbol_levels(symbol)
+            symbol_ts = self._symbol_level_ts(symbol)
             for change in bucket["changes"]:
                 side = "b" if str(change.get("side") or "").upper() == "BUY" else "a"
                 price_ticks = self._price_to_ticks(change.get("price"))
@@ -891,26 +920,30 @@ class Book(DataStore):
                 if price_ticks is None or size_units is None:
                     continue
                 side_levels = symbol_levels[side]
+                side_ts = symbol_ts[side]
                 key = (symbol, side, price_ticks)
 
                 if size_units <= 0:
                     if price_ticks in side_levels:
                         side_levels.pop(price_ticks, None)
+                        side_ts.pop(price_ticks, None)
                         removals[key] = self._delete_key(
                             symbol=symbol, side=side, price_ticks=price_ticks
                         )
                         updates.pop(key, None)
                     continue
 
-                if side_levels.get(price_ticks) == size_units:
+                if side_levels.get(price_ticks) == size_units and side_ts.get(price_ticks) == bucket["seq"]:
                     continue
                 side_levels[price_ticks] = size_units
+                side_ts[price_ticks] = bucket["seq"]
                 updates[key] = self._record(
                     symbol=symbol,
                     side=side,
                     price_ticks=price_ticks,
                     size_units=size_units,
                     alias=alias,
+                    event_time_ms=bucket["seq"],
                 )
                 removals.pop(key, None)
 
@@ -976,6 +1009,7 @@ class Book(DataStore):
                     "S": side,
                     "p": self._ticks_to_price(price_ticks),
                     "q": self._units_to_size(side_levels[price_ticks]),
+                    "event_time_ms": self._level_ts.get(str(symbol), {}).get(side, {}).get(price_ticks),
                 }
                 if alias is not None:
                     row["alias"] = alias
@@ -1093,6 +1127,7 @@ class BBO(DataStore):
         key = {"s": symbol, "S": side}
         current = self.get(key)
         best = self._symbol_best(symbol).get(side)
+        event_time_ms = self._last_seq.get(symbol)
 
         if best is None:
             if current:
@@ -1105,6 +1140,7 @@ class BBO(DataStore):
             "S": side,
             "p": self._price_to_str(price_ticks),
             "q": self._size_to_str(size_units),
+            "event_time_ms": event_time_ms,
         }
         if alias is not None:
             payload["alias"] = alias
@@ -1113,12 +1149,17 @@ class BBO(DataStore):
             cur_price = str(current.get("p"))
             cur_size = str(current.get("q"))
             cur_alias = current.get("alias")
+            cur_event_time_ms = current.get("event_time_ms")
             new_price = payload["p"]
             new_size = payload["q"]
 
             if cur_price == new_price:
-                # price unchanged -> only update quantities / alias changes
-                if cur_size != new_size or (alias is not None and cur_alias != alias):
+                # price unchanged -> only update quantities / alias / timestamp changes
+                if (
+                    cur_size != new_size
+                    or (alias is not None and cur_alias != alias)
+                    or cur_event_time_ms != event_time_ms
+                ):
                     self._update([payload])
                 return
 
@@ -1247,7 +1288,8 @@ class BBO(DataStore):
         symbol, alias = self._alias(asset_id)
         if symbol is None:
             return
-        if not self._accept_sequence(symbol, Book._extract_timestamp(msg)):
+        event_time_ms = Book._extract_timestamp(msg)
+        if not self._accept_sequence(symbol, event_time_ms):
             return
 
         bid_size = None

{hyperquant-1.61 → hyperquant-1.62}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.6"
+version = "1.61"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },