fixtureqa 0.4.31__tar.gz → 0.4.33__tar.gz

{fixtureqa-0.4.31/fixtureqa.egg-info → fixtureqa-0.4.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.31
+Version: 0.4.33
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.31 → fixtureqa-0.4.33}/fixture/core/perf_engine.py

@@ -311,10 +311,11 @@ class PerfRun:
             # User pressed Stop — wind down promptly; don't wait on the backlog.
             await asyncio.sleep(_GRACE_DRAIN_S)
         elif self._has_client and self._has_venue:
-            # loopback/manager natural end (count OR duration): the in-process venue
-            # still owes fills for the backlog — wait until they're all received,
-            # rather than cutting off and marking in-flight orders lost.
-            await self._drain_until_filled()
+            # loopback/manager/middle_manager natural end (count OR duration): the
+            # in-process venue still owes fills AND cancel/amend replies — wait until
+            # every chain is terminal, rather than cutting off and marking in-flight
+            # orders/cancels/amends lost.
+            await self._drain_until_quiescent()
         elif self._reached_max_orders:
             # client mode, count-bounded: external venue may never fill — bounded settle.
             deadline = time.perf_counter() + max(_GRACE_DRAIN_S,
@@ -363,16 +364,40 @@ class PerfRun:
         self._publish()
         self._writer.write_run(self._run_record(final=True))
 
-    async def _drain_until_filled(self) -> None:
-        """loopback/manager drain (count- OR duration-bounded): the in-process venue
-        still has a backlog of orders to fill (rate-limited), so wait until it has
-        filled the whole backlog and the client has received those fills — rather
-        than cutting off at the stop condition and marking in-flight orders lost.
+    def _activity_count(self) -> int:
+        """Monotonic tally of every terminal-chain event — fills/acks AND cancel/
+        amend replies — so the drain's quiet window measures from the last reply,
+        not just the last fill."""
+        s = self.stats
+        return (s.fills_sent + s.acks_sent + s.cancel_rejects + s.cancels_canceled
+                + s.replaces_received + s.amend_rejects)
+
+    def _drain_quiescent(self, now: float, last_activity: float, quiet: float) -> bool:
+        """True when the in-process venue has nothing left in flight: inbound queue
+        and order book empty, the client's queue drained, NO cancel/amend reply still
+        outstanding on any pending order, and no chain event for a quiet window. The
+        in-flight-reply check is what makes a cancel/amend run reconcile to 100% —
+        without it the run would end on fill-quiescence while a 35=9/150=4/replace
+        ack was still on the wire (counted lost)."""
+        replies_inflight = any(e.get("cancel_inflight") or e.get("amend_inflight")
+                               for e in self._pending.values())
+        return (self._venue_sub.qsize() == 0 and self._client_sub.qsize() == 0
+                and not self._venue_orders and not replies_inflight
+                and (now - last_activity) >= quiet)
+
+    async def _drain_until_quiescent(self) -> None:
+        """loopback/manager/middle_manager drain (count- OR duration-bounded): the
+        in-process venue still owes fills for the backlog AND cancel/amend replies for
+        any in-flight 35=F/35=G, so wait until every chain is terminal — rather than
+        cutting off at the stop condition and marking in-flight orders/cancels/amends
+        lost. (Cancel-on-ack cancels fired for orders acked during the drain are
+        awaited too — they land in _pending with cancel_inflight.)
 
         The timeout sweeper is paused (``_draining_full``) so backlogged orders
         aren't expired mid-drain; orders the venue won't fill (fill_ratio<1 / partial)
         settle out via quiescence and are finalized after. Bounded by a generous cap
-        derived from the backlog and fill rate as a safety net against a stuck run."""
+        derived from the backlog, fill rate, amend grace and reply round-trip as a
+        safety net against a stuck run (e.g. a reply that never comes)."""
         self._draining_full = True
         r = self.config.rate
         fill_rate = r.fills_per_window / (r.fill_window_ms / 1000.0)   # fills/sec
@@ -382,10 +407,15 @@ class PerfRun:
         # latest (no new holds once injection stops), so add one grace.
         backlog = (self._venue_sub.qsize() * max(1, self.config.payload.fill.fills_per_order)
                    + sum(len(e["schedule"]) - e["idx"] for e in self._venue_orders.values()))
+        # Reply budget: cancel/amend replies are immediate but still round-trip — give
+        # the cap headroom (observed response p99, capped) so it can't fire before the
+        # last in-flight reply is due back.
+        reply_budget = min(30.0, self.stats.response_latency.stats()["p99_us"] / 1e6 * 2.0)
         cap = time.perf_counter() + max(30.0, (backlog / max(1.0, fill_rate)) * 2.0
-                                        + self.config.amend.amend_wait_ms / 1000.0 + 10.0)
+                                        + self.config.amend.amend_wait_ms / 1000.0
+                                        + reply_budget + 10.0)
 
-        last_sent = self.stats.fills_sent + self.stats.acks_sent
+        last_count = self._activity_count()
         last_activity = time.perf_counter()
         while True:
             now = time.perf_counter()
@@ -393,18 +423,11 @@ class PerfRun:
             # finalized as lost instead of ground through at the fill rate.
             if self._stopped_by_user or not self._pending or now >= cap:
                 break
-            cur_sent = self.stats.fills_sent + self.stats.acks_sent
-            if cur_sent != last_sent:
-                last_sent = cur_sent
+            cur = self._activity_count()
+            if cur != last_count:
+                last_count = cur
                 last_activity = now
-            # Done when the venue has drained its backlog (inbound queue AND
-            # order book), the client has received the fills, and no new
-            # fill/ack has gone out for a quiet window (covers the
-            # rate-limited last order still being filled).
-            quiet_ok = (self._venue_sub.qsize() == 0 and self._client_sub.qsize() == 0
-                        and not self._venue_orders
-                        and (now - last_activity) >= quiet)
-            if quiet_ok:
+            if self._drain_quiescent(now, last_activity, quiet):
                 break
             await asyncio.sleep(0.02)