fixtureqa 0.4.14__tar.gz → 0.4.16__tar.gz

{fixtureqa-0.4.14/fixtureqa.egg-info → fixtureqa-0.4.16}/PKG-INFO

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

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/perf_engine.py

@@ -108,9 +108,12 @@ class PerfRun:
         self._pending: dict[str, dict] = {}
         self._order_seq = 0
 
-        # Amend injection is fill-triggered on the client leg (35=D orders only).
+        # Amend injection is fill-triggered on the client leg (35=D orders only);
+        # cancel injection is ack- or fill-triggered. Both park their send tasks
+        # in _aux_tasks (strong refs; cancelled together at shutdown).
         self._amend_on = config.amend.enabled and self._has_client
-        self._amend_tasks: set[asyncio.Task] = set()
+        self._cancel_on = config.cancel.enabled and self._has_client
+        self._aux_tasks: set[asyncio.Task] = set()
 
         # Venue order book: corr → resumable fill state. The dispatcher books
         # orders; _fill_sender drains them round-robin (via _fill_runnable),
@@ -167,6 +170,10 @@ class PerfRun:
             self.warnings.append(
                 "amend injection has no effect in venue mode (no client leg); "
                 "inbound 35=G from the external client is still answered")
+        if self.config.cancel.enabled and not self._has_client:
+            self.warnings.append(
+                "cancel injection has no effect in venue mode (no client leg); "
+                "inbound 35=F from the external client is still answered")
         if self._has_client:
             self._client_sub = self._sm.subscribe_session(self.config.client_session_id)
         if self._has_venue:
@@ -218,12 +225,14 @@ class PerfRun:
                 await asyncio.sleep(0.02)
         else:
             await asyncio.sleep(_GRACE_DRAIN_S)
-        for t in list(self._tasks) + list(self._amend_tasks):
+        for t in list(self._tasks) + list(self._aux_tasks):
             t.cancel()
-        await asyncio.gather(*self._tasks, *self._amend_tasks, return_exceptions=True)
+        await asyncio.gather(*self._tasks, *self._aux_tasks, return_exceptions=True)
         for entry in list(self._pending.values()):
             if entry.get("amend_inflight"):
                 self.stats.amends_lost += 1
+            if entry.get("cancel_inflight"):
+                self.stats.cancels_lost += 1
             self._finalize(entry, "filled" if entry.get("completed") else "lost")
         self._pending.clear()
         self._venue_orders.clear()
@@ -351,6 +360,11 @@ class PerfRun:
             meta["amends_sent"] = 0
             meta["amend_inflight"] = False
             meta["completed"] = False
+        if self._cancel_on and meta.get("msg_type") == "D":
+            meta["cancel_eligible"] = random.random() < self.config.cancel.cancel_ratio
+            meta["cancel_sent"] = False
+            meta["cancel_inflight"] = False
+            meta.setdefault("completed", False)
         if resp_event is not None:
             meta["resp_event"] = resp_event
         self._pending[meta["corr_id"]] = meta
@@ -425,6 +439,9 @@ class PerfRun:
             if inb.msg_type == "G":
                 await self._handle_amend(inb.fields)
                 continue
+            if inb.msg_type == "F":
+                await self._handle_cancel(inb.fields)
+                continue
             if inb.msg_type != "D":
                 continue
             self.stats.orders_received += 1
@@ -566,6 +583,62 @@ class PerfRun:
         if er is not None:
             await self._sm.send_message(cfg.venue_session_id, er)
 
+    async def _handle_cancel(self, of: dict) -> None:
+        """Venue side of 35=F, per config.cancel.venue_response: "reject"
+        answers 35=9 OrderCancelReject (CxlRejReason from config, correlation
+        tag echoed) and the order keeps working — the cancel-reject flavour;
+        "cancel" answers 150=4/39=4 Canceled with the real CumQty and stops
+        any remaining fills. Like acks, replies are immediate, not
+        fill-rate-limited; unknown orders reply stateless."""
+        cfg = self.config
+        self.stats.cancels_received += 1
+        corr = of.get(cfg.correlation_tag)
+        if corr is None:
+            # Can't reply — there is nothing to echo for the client to correlate.
+            self.stats.cancels_uncorrelated += 1
+            if self.stats.cancels_uncorrelated == 1:
+                self.warnings.append(
+                    f"venue received 35=F without correlation tag "
+                    f"{cfg.correlation_tag} — no reply sent; check the "
+                    f"counterparty passes the tag through on cancels")
+            return
+        entry = self._venue_orders.get(corr)
+        if cfg.cancel.venue_response == "cancel":
+            if entry is not None:
+                cum, px = entry["cum"], entry["px"]
+                self._venue_orders.pop(corr, None)   # stop remaining fills
+            else:
+                cum, px = 0, of.get(T_PRICE) or "0"
+            er = self._build_exec(of, exec_type="4", ord_status="4", last_qty=0,
+                                  cum_qty=cum, leaves_qty=0, px=px,
+                                  orig_clordid=of.get(T_ORIGCLORDID))
+            if er is not None:
+                await self._sm.send_message(cfg.venue_session_id, er)
+            return
+        msg = self._build_cancel_reject(of, entry)
+        await self._sm.send_message(cfg.venue_session_id, msg)
+
+    def _build_cancel_reject(self, of: dict, entry: Optional[dict]) -> Message:
+        """35=9 OrderCancelReject answering a 35=F: CxlRejResponseTo(434)=1,
+        CxlRejReason(102) from config, OrdStatus(39) from the book when the
+        order is known, correlation tag echoed so the client can close its
+        in-flight cancel."""
+        cfg = self.config
+        clordid = of.get(T_CLORDID, "")
+        msg = Message()
+        msg.header.set(T_MSGTYPE, "9")
+        msg.set_field(T_CLORDID, clordid)
+        msg.set_field(T_ORIGCLORDID, of.get(T_ORIGCLORDID) or clordid)
+        msg.set_field(T_ORDERID, "NONE")
+        cum = entry["cum"] if entry is not None else 0
+        msg.set_field(T_ORDSTATUS, "1" if cum > 0 else "0")
+        msg.set_field(102, str(cfg.cancel.cxl_rej_reason))
+        msg.set_field(434, "1")
+        corr = of.get(cfg.correlation_tag)
+        if corr:
+            msg.set_field(cfg.correlation_tag, corr)
+        return msg
+
     def _exec(self, of: dict, **kw) -> Optional[Message]:
         """Build one ExecReport via the exec template when configured, else the
         built-in builder (Phase B). Both enforce the standard correlation tags."""
@@ -581,6 +654,8 @@ class PerfRun:
         fill_type: 'full' completes the order (final 150=2/39=2); 'partial' stops
         at partial_fill_pct% and never completes (all 150=1/39=1)."""
         f = self.config.payload.fill
+        if f.fills_per_order == 0:
+            return []   # ack-only orders (cancel flavour): never booked, no fills
         ftype = f.fill_type
         if ftype == "random":
             ftype = random.choice(("full", "partial"))
@@ -652,31 +727,94 @@ class PerfRun:
         while True:
             inb = await sub.get()
             if inb.msg_type == "9":
-                self._on_cancel_reject(inb.fields)
+                self._on_cancel_reject(inb.fields, inb.recv_perf_ns or time.perf_counter_ns())
                 continue
             if inb.msg_type != "8":
                 continue
             self._on_exec_report(inb.fields, inb.recv_perf_ns or time.perf_counter_ns())
 
-    def _on_cancel_reject(self, f: dict) -> None:
-        """OrderCancelReject (35=9): the counterparty refused the amend. Count
-        it (these would otherwise be invisible — only 35=8 is correlated) and
-        release the in-flight amend so the order finalizes normally instead of
-        being reaped as amends_lost."""
+    def _on_cancel_reject(self, f: dict, now_ns: int) -> None:
+        """OrderCancelReject (35=9): answers either a 35=F (CxlRejResponseTo
+        434=1 — the cancel-reject flavour's expected reply) or a 35=G (434=2 —
+        an amend the counterparty refused). Dispatch on 434; when it's absent,
+        infer from which request is in flight on the correlated entry."""
+        corr = f.get(self.config.correlation_tag)
+        entry = self._pending.get(corr) if corr is not None else None
+        resp_to = f.get(434)
+        if resp_to == "1" or (resp_to is None and entry is not None
+                              and entry.get("cancel_inflight")
+                              and not entry.get("amend_inflight")):
+            self._on_cancel_rejected(corr, entry, now_ns)
+            return
         self.stats.amend_rejects += 1
         if self.stats.amend_rejects == 1:
             self.warnings.append(
                 "counterparty rejected an amend (35=9 OrderCancelReject) — "
                 "it may not match OrigClOrdID(41) against its own order chain")
-        corr = f.get(self.config.correlation_tag)
-        entry = self._pending.get(corr) if corr is not None else None
         if entry is None or not entry.get("amend_inflight"):
             return
         entry["amend_inflight"] = False
         entry["pending_clordid"] = None        # chain tip stays at the last accepted
+        if entry.get("completed") and not entry.get("cancel_inflight"):
+            self._pending.pop(corr, None)
+            self._finalize(entry, "filled")
+
+    def _on_cancel_rejected(self, corr: str, entry: Optional[dict], now_ns: int) -> None:
+        """The counterparty refused this order's 35=F. In the ack-only flavour
+        (fills_per_order=0) the reject is the order's terminal event."""
+        self.stats.cancel_rejects += 1
+        if entry is None or not entry.get("cancel_inflight"):
+            return
+        sent_ns = entry.get("cancel_sent_ns")
+        if sent_ns:
+            self.stats.cancel_latency.add((now_ns - sent_ns) / 1000.0)
+        entry["cancel_inflight"] = False
+        if entry.get("amend_inflight"):
+            return   # still awaiting the amend reply; that path finalizes
         if entry.get("completed"):
             self._pending.pop(corr, None)
             self._finalize(entry, "filled")
+        elif self.config.payload.fill.fills_per_order == 0:
+            # Ack-only order: no fill will ever finalize it — the reject does.
+            entry["completed"] = True
+            self._pending.pop(corr, None)
+            self._finalize(entry, "cancel_rejected")
+
+    def _on_canceled(self, corr: str, entry: dict, now_ns: int) -> None:
+        """Client got a Canceled ack (150=4): terminal for the order — unless
+        it fully filled first (the venue's stateless fallback answers a late F
+        on a completed order), which the fill completion already accounted."""
+        sent_ns = entry.get("cancel_sent_ns")
+        if entry.get("cancel_inflight") and sent_ns:
+            self.stats.cancel_latency.add((now_ns - sent_ns) / 1000.0)
+        entry["cancel_inflight"] = False
+        if entry.get("completed"):
+            if not entry.get("amend_inflight"):
+                self._pending.pop(corr, None)
+                self._finalize(entry, "filled")
+            return
+        self.stats.cancels_canceled += 1
+        entry["completed"] = True
+        self._pending.pop(corr, None)
+        self._finalize(entry, "canceled")
+
+    def _launch_cancel(self, entry: dict) -> None:
+        entry["cancel_sent"] = True
+        entry["cancel_inflight"] = True
+        t = asyncio.create_task(self._send_cancel(entry))
+        self._aux_tasks.add(t)
+        t.add_done_callback(self._aux_tasks.discard)
+
+    async def _send_cancel(self, entry: dict) -> None:
+        """Build and send the order's one 35=F (on the ack for after_fills=0,
+        else on the nth fill) — demand-driven, no pacer of its own."""
+        msg, new_clordid = self._factory.build_cancel(entry)
+        entry["cancel_clordid"] = new_clordid
+        entry["cancel_sent_ns"] = time.perf_counter_ns()
+        if await self._sm.send_message(self.config.client_session_id, msg):
+            self.stats.cancels_sent += 1
+        else:
+            entry["cancel_inflight"] = False
 
     def _on_exec_report(self, f: dict, now_ns: int) -> None:
         cfg = self.config
@@ -704,12 +842,15 @@ class PerfRun:
                 ((now_ns - prev_ns) / 1000.0) if prev_ns is not None else None,
             ))
 
-        # Amend responses (Pending Replace / Replaced) are not order responses:
-        # they must not count as first response, a fill, or a completion.
+        # Amend/cancel responses (Pending Replace / Replaced / Pending Cancel /
+        # Canceled) are not order responses: they must not count as first
+        # response, a fill, or a completion.
         exec_type = f.get(T_EXECTYPE)
-        if exec_type in ("E", "5"):
+        if exec_type in ("E", "5", "6", "4"):
             if exec_type == "5":
                 self._on_replaced(corr, entry, now_ns)
+            elif exec_type == "4":
+                self._on_canceled(corr, entry, now_ns)
             return
 
         if not entry["responded"]:
@@ -723,23 +864,47 @@ class PerfRun:
             if ev is not None:
                 ev.set()
 
+        # Cancel trigger, on-ack flavour (after_fills=0): the first response is
+        # the ack — send the order's one 35=F as soon as the order exists
+        # downstream. cancel_sent guards re-entry on later execs. Deliberately
+        # NOT gated on _injecting: the venue answers a 35=F at any time, and in
+        # the ack-only flavour the reply is what finalizes orders acked during
+        # the end-of-run drain.
+        if (self._cancel_on and entry.get("cancel_eligible")
+                and not entry.get("cancel_sent")
+                and self.config.cancel.after_fills == 0):
+            self._launch_cancel(entry)
+
         cum = _to_int(f.get(T_CUMQTY), 0)
 
-        # Amend trigger: every nth fill of a still-working order. Counting cum
-        # increases (not ExecType values) keeps it venue-agnostic (4.2's 150=1/2
-        # and 4.4's 150=F alike). Never fires on the final fill.
-        if self._amend_on and entry.get("amend_eligible") and cum > entry.get("cum_seen", 0):
+        # Fill counting: cum increases (not ExecType values) keep it
+        # venue-agnostic (4.2's 150=1/2 and 4.4's 150=F alike).
+        if cum > entry.get("cum_seen", 0):
             entry["cum_seen"] = cum
-            entry["fills_seen"] += 1
-            a = self.config.amend
-            if (self._injecting and not entry["amend_inflight"]
-                    and cum < entry["order_qty"]
-                    and entry["fills_seen"] % a.every_n_fills == 0
-                    and (a.max_per_order == 0 or entry["amends_sent"] < a.max_per_order)):
-                entry["amend_inflight"] = True
-                t = asyncio.create_task(self._send_amend(entry))
-                self._amend_tasks.add(t)
-                t.add_done_callback(self._amend_tasks.discard)
+            entry["fills_seen"] = entry.get("fills_seen", 0) + 1
+
+            # Amend trigger: every nth fill of a still-working order.
+            # Never fires on the final fill.
+            if self._amend_on and entry.get("amend_eligible"):
+                a = self.config.amend
+                if (self._injecting and not entry["amend_inflight"]
+                        and cum < entry["order_qty"]
+                        and entry["fills_seen"] % a.every_n_fills == 0
+                        and (a.max_per_order == 0 or entry["amends_sent"] < a.max_per_order)):
+                    entry["amend_inflight"] = True
+                    t = asyncio.create_task(self._send_amend(entry))
+                    self._aux_tasks.add(t)
+                    t.add_done_callback(self._aux_tasks.discard)
+
+            # Cancel trigger, nth-fill flavour: one 35=F on the configured
+            # fill of a still-working order. Not gated on _injecting (see the
+            # on-ack trigger above).
+            if (self._cancel_on and entry.get("cancel_eligible")
+                    and not entry.get("cancel_sent")
+                    and self.config.cancel.after_fills > 0
+                    and entry["fills_seen"] == self.config.cancel.after_fills
+                    and cum < entry["order_qty"]):
+                self._launch_cancel(entry)
 
         if cum >= entry["order_qty"] and not entry.get("completed"):
             lat_us = (now_ns - entry["sent_ns"]) / 1000.0
@@ -749,11 +914,11 @@ class PerfRun:
             entry["fill_price"] = f.get(T_LASTPX) or f.get(T_AVGPX)
             self.stats.completions += 1
             self.stats.fill_completion_latency.add(lat_us)
-            if entry.get("amend_inflight"):
-                # The venue dispatches an order's fills before it reads the 35=G,
-                # so the Replaced ack usually lands after the final fill. Keep
-                # the entry so the ack still correlates; _on_replaced (or the
-                # sweeper / shutdown) finalizes it.
+            if entry.get("amend_inflight") or entry.get("cancel_inflight"):
+                # An amend/cancel reply can land after the final fill (the
+                # venue answers the G/F it reads after dispatching fills).
+                # Keep the entry so the reply still correlates; _on_replaced /
+                # _on_cancel_rejected (or the sweeper / shutdown) finalizes it.
                 entry["completed"] = True
             else:
                 entry["completed"] = True
@@ -770,7 +935,7 @@ class PerfRun:
             entry["clordid"] = entry["pending_clordid"]
             entry["pending_clordid"] = None
         entry["amend_inflight"] = False
-        if entry.get("completed"):
+        if entry.get("completed") and not entry.get("cancel_inflight"):
             self._pending.pop(corr, None)
             self._finalize(entry, "filled")
 
@@ -811,8 +976,10 @@ class PerfRun:
                     continue
                 if entry.get("amend_inflight"):
                     self.stats.amends_lost += 1
+                if entry.get("cancel_inflight"):
+                    self.stats.cancels_lost += 1
                 if entry.get("completed"):
-                    # Order filled; only the amend's Replaced ack never came —
+                    # Order filled; only the amend/cancel reply never came —
                     # don't double-count a completed order as lost.
                     self._finalize(entry, "filled")
                 else:
@@ -858,6 +1025,10 @@ class PerfRun:
                 amends_lost=self.stats.amends_lost,
                 amend_rejects=self.stats.amend_rejects,
                 aps_live=round(aps, 1),
+                cancels_sent=self.stats.cancels_sent,
+                cancel_rejects=self.stats.cancel_rejects,
+                cancels_canceled=self.stats.cancels_canceled,
+                cancels_lost=self.stats.cancels_lost,
                 scenarios_dispatched=self.stats.scenarios_dispatched,
                 scenarios_per_sec=round(sps, 1),
                 scenarios_completed=self.stats.scenarios_completed,
@@ -872,7 +1043,9 @@ class PerfRun:
                 unfilled=max(0, self.stats.orders_sent - self.stats.completions),
                 amends_received=self.stats.amends_received,
                 amends_uncorrelated=self.stats.amends_uncorrelated,
-                amend_waits_expired=self.stats.amend_waits_expired)
+                amend_waits_expired=self.stats.amend_waits_expired,
+                cancels_received=self.stats.cancels_received,
+                cancels_uncorrelated=self.stats.cancels_uncorrelated)
         snap = LiveSnapshot(
             run_id=self.run_id, status=self.status, mode=self.config.mode,
             elapsed_s=round(self._elapsed_s(), 1), duration_s=self.config.test.duration,
@@ -881,6 +1054,7 @@ class PerfRun:
             response_latency=LatencyStats(**self.stats.response_latency.stats()),
             fill_completion_latency=LatencyStats(**self.stats.fill_completion_latency.stats()),
             amend_latency=LatencyStats(**self.stats.amend_latency.stats()),
+            cancel_latency=LatencyStats(**self.stats.cancel_latency.stats()),
             scenario_latency=LatencyStats(**self.stats.scenario_latency.stats()),
             errors=SnapshotErrors(lost_timeout=self.stats.lost_timeout,
                                   rejected=self.stats.rejected,

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/perf_models.py

@@ -84,6 +84,26 @@ class AmendConfig(BaseModel):
     amend_wait_ms: int = Field(default=2000, gt=0)
 
 
+class CancelConfig(BaseModel):
+    """Client-leg cancel traffic (35=F OrderCancelRequest) — a run flavour
+    alongside amends.
+
+    `after_fills` picks the trigger: 0 sends the F as soon as the order is
+    acked (the D > ack > F > reply flavour; pair with fills_per_order=0 for a
+    pure no-fill run), n sends it after the nth fill. `cancel_ratio` picks the
+    eligible fraction of orders; one F per order.
+
+    `venue_response` shapes the in-process venue's reply: "reject" answers
+    35=9 OrderCancelReject (CxlRejReason=`cxl_rej_reason`, CxlRejResponseTo=1,
+    correlation tag echoed) and the order keeps working; "cancel" answers
+    150=4/39=4 Canceled with the real CumQty and stops any remaining fills."""
+    enabled: bool = False
+    after_fills: int = Field(default=0, ge=0)
+    cancel_ratio: float = Field(default=1.0, ge=0.0, le=1.0)
+    venue_response: Literal["reject", "cancel"] = "reject"
+    cxl_rej_reason: int = Field(default=0, ge=0)   # tag 102; 0 = too late to cancel
+
+
 class OrderPayloadConfig(BaseModel):
     symbols: list[str] = Field(min_length=1)
     side: Literal["fixed_buy", "fixed_sell", "alternate", "random"] = "alternate"
@@ -108,8 +128,9 @@ class FillPayloadConfig(BaseModel):
     # FIX lifecycle: ack the order (35=8|150=0|39=0) before any fills.
     send_ack: bool = True
     # Split a filled order into N ExecutionReports: N-1 partials then a final fill
-    # bringing CumQty to OrderQty (1 = single fill).
-    fills_per_order: int = Field(default=1, gt=0)
+    # bringing CumQty to OrderQty (1 = single fill; 0 = ack-only, no fills —
+    # the cancel flavour's D > ack > F > reply sequence).
+    fills_per_order: int = Field(default=1, ge=0)
     partial_fill_pct_min: int = Field(default=50, ge=1, le=100)
     partial_fill_pct_max: int = Field(default=99, ge=1, le=100)
     price_variance_ticks: int = Field(default=0, ge=0)
@@ -174,6 +195,7 @@ class RunConfig(BaseModel):
     rate: RateConfig
     test: TestConfig = Field(default_factory=TestConfig)
     amend: AmendConfig = Field(default_factory=AmendConfig)
+    cancel: CancelConfig = Field(default_factory=CancelConfig)
     payload: PayloadConfig
 
     @model_validator(mode="after")
@@ -184,6 +206,15 @@ class RunConfig(BaseModel):
             raise ValueError(f"mode {self.mode!r} requires client_session_id")
         if need_venue and not self.venue_session_id:
             raise ValueError(f"mode {self.mode!r} requires venue_session_id")
+        if self.payload.fill.fills_per_order == 0:
+            # Ack-only orders never complete via fills: without a cancel reply
+            # to finalize them, every order just times out as lost.
+            if not self.cancel.enabled:
+                raise ValueError("fills_per_order=0 requires the cancel flavour "
+                                 "(cancel.enabled) — ack-only orders never fill")
+            if self.cancel.after_fills > 0:
+                raise ValueError("cancel.after_fills > 0 needs fills: "
+                                 "with fills_per_order=0 the 35=F would never trigger")
         return self
 
 
@@ -210,6 +241,10 @@ class ClientLeg(BaseModel):
     amends_lost: int = 0
     amend_rejects: int = 0
     aps_live: float = 0.0
+    cancels_sent: int = 0
+    cancel_rejects: int = 0
+    cancels_canceled: int = 0
+    cancels_lost: int = 0
     scenarios_dispatched: int = 0
     scenarios_per_sec: float = 0.0
     scenarios_completed: int = 0
@@ -227,6 +262,8 @@ class VenueLeg(BaseModel):
     amends_received: int = 0
     amends_uncorrelated: int = 0
     amend_waits_expired: int = 0
+    cancels_received: int = 0
+    cancels_uncorrelated: int = 0
 
 
 class SnapshotErrors(BaseModel):
@@ -247,6 +284,7 @@ class LiveSnapshot(BaseModel):
     response_latency: LatencyStats = Field(default_factory=LatencyStats)
     fill_completion_latency: LatencyStats = Field(default_factory=LatencyStats)
     amend_latency: LatencyStats = Field(default_factory=LatencyStats)
+    cancel_latency: LatencyStats = Field(default_factory=LatencyStats)
     scenario_latency: LatencyStats = Field(default_factory=LatencyStats)
     errors: SnapshotErrors = Field(default_factory=SnapshotErrors)
 

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/perf_payload.py

@@ -427,6 +427,29 @@ class PayloadFactory:
         msg.set_field(60, _utc_ms())
         return msg, new_clordid
 
+    # -- cancel (35=F OrderCancelRequest) --------------------------------
+
+    def build_cancel(self, meta: dict) -> tuple[Message, str]:
+        """Cancel a working order. Carries the order's correlation id so the
+        reply (35=9 reject or 150=4 Canceled) routes to the same pending
+        entry; OrigClOrdID(41) is the current chain tip, ClOrdID(11) is
+        fresh. Routing/identity tags (AMEND_MIRROR_TAGS) are echoed verbatim
+        from the order, exactly like amends — endpoints commonly require
+        them to match across the chain."""
+        new_clordid = self._clordid()
+        msg = Message()
+        msg.header.set(35, "F")
+        msg.set_field(11, new_clordid)
+        msg.set_field(41, meta["clordid"])
+        msg.set_field(self.config.correlation_tag, meta["corr_id"])
+        for tag, val in (meta.get("mirror_tags") or {}).items():
+            msg.set_field(tag, val)
+        msg.set_field(55, meta["symbol"])
+        msg.set_field(54, meta["side"])
+        msg.set_field(38, str(meta["order_qty"]))
+        msg.set_field(60, _utc_ms())
+        return msg, new_clordid
+
     def _apply_expiry(self, msg: Message, fields: dict) -> None:
         """Rewrite ExpireTime(126)/ExpireDate(432) to a shared future instant —
         only for tags the message already carries (never inserts), exactly like

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/perf_stats.py

@@ -126,6 +126,12 @@ class PerfStats:
         self.amends_received = 0     # venue saw an inbound 35=G
         self.amends_uncorrelated = 0  # inbound 35=G lacked the correlation tag (no reply)
         self.amend_waits_expired = 0  # venue fill-hold released by grace, not by a 35=G
+        self.cancels_sent = 0        # client sent a 35=F
+        self.cancel_rejects = 0      # client got a 35=9 answering its 35=F (434=1)
+        self.cancels_canceled = 0    # client got a Canceled ack (150=4)
+        self.cancels_lost = 0        # cancel in flight when its order was reaped
+        self.cancels_received = 0    # venue saw an inbound 35=F
+        self.cancels_uncorrelated = 0  # inbound 35=F lacked the correlation tag (no reply)
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0
@@ -138,6 +144,7 @@ class PerfStats:
         self.response_latency = _Reservoir(reservoir_size)
         self.fill_completion_latency = _Reservoir(reservoir_size)
         self.amend_latency = _Reservoir(reservoir_size)
+        self.cancel_latency = _Reservoir(reservoir_size)
         self.scenario_latency = _Reservoir(reservoir_size)
 
         self._last_t = time.monotonic()
@@ -186,6 +193,12 @@ class PerfStats:
             "amends_received": self.amends_received,
             "amends_uncorrelated": self.amends_uncorrelated,
             "amend_waits_expired": self.amend_waits_expired,
+            "cancels_sent": self.cancels_sent,
+            "cancel_rejects": self.cancel_rejects,
+            "cancels_canceled": self.cancels_canceled,
+            "cancels_lost": self.cancels_lost,
+            "cancels_received": self.cancels_received,
+            "cancels_uncorrelated": self.cancels_uncorrelated,
             "lost_timeout": self.lost_timeout,
             "dropped": self.dropped,
             "rejected": self.rejected,
@@ -196,5 +209,6 @@ class PerfStats:
             "response_latency": self.response_latency.stats(),
             "fill_completion_latency": self.fill_completion_latency.stats(),
             "amend_latency": self.amend_latency.stats(),
+            "cancel_latency": self.cancel_latency.stats(),
             "scenario_latency": self.scenario_latency.stats(),
         }

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/session.py

@@ -51,14 +51,8 @@ class Session:
     def __init__(self, config: SessionConfig, event_handler: EventHandler,
                  msg_writer: Optional["MessageWriter"] = None):
         self.config = config
-        if msg_writer is not None and config.log_messages:
-            from .message_store import MessageStore
-            self._message_log = MessageStore(config.session_id, msg_writer)
-        else:
-            # No persistent writer, or logging disabled for this session
-            # (high-rate/perf): in-memory log only, no per-message SQLite churn.
-            from .message_log import MessageLog
-            self._message_log = MessageLog()
+        self._msg_writer = msg_writer
+        self._message_log = self._pick_message_log()
         self.state = SessionState(config=config, message_log=self._message_log)
         self._event_handler = event_handler
         self._transport: Optional[SocketInitiator | SocketAcceptor] = None
@@ -69,6 +63,23 @@ class Session:
         # and the ack/fill silently never sent.
         self._venue_tasks: set[asyncio.Task] = set()
 
+    def _pick_message_log(self):
+        if self._msg_writer is not None and self.config.log_messages:
+            from .message_store import MessageStore
+            return MessageStore(self.config.session_id, self._msg_writer)
+        # No persistent writer, or logging disabled for this session
+        # (high-rate/perf): in-memory log only, no per-message SQLite churn.
+        from .message_log import MessageLog
+        return MessageLog()
+
+    def rebind_message_log(self) -> None:
+        """Re-run the log-backend choice after config.log_messages changed
+        (standard <-> perf conversion on a stopped session). Switching to the
+        persistent store re-exposes the session's messages.db history; the
+        in-memory ring from perf mode is not carried over."""
+        self._message_log = self._pick_message_log()
+        self.state.message_log = self._message_log
+
     # ------------------------------------------------------------------
     # Public API
     # ------------------------------------------------------------------

{fixtureqa-0.4.14 → fixtureqa-0.4.16}/fixture/core/session_manager.py

@@ -1,5 +1,7 @@
 import copy
 import logging
+import os
+import shutil
 import threading
 from typing import Dict, List, Optional, Set
 from .models import SessionConfig, SessionState, SessionStatus
@@ -73,7 +75,15 @@ class SessionManager:
         await self._get(session_id).stop(force=force)
 
     def update_session(self, session_id: str, req) -> SessionConfig:
-        """Update config fields on a stopped session."""
+        """Update config fields on a stopped session.
+
+        Standard <-> perf conversion happens here too: `durable_seqnums` and
+        the engine-side logging are start-time decisions and need nothing,
+        but flipping `log_messages` rebinds the message-log backend
+        (SQLite-backed store vs in-memory ring), and flipping
+        `durable_seqnums` clears the session's file store so the next start
+        gets clean seqnums instead of resuming from a stale file.
+        """
         from .models import ConnectionType, SessionRole
         session = self._get(session_id)
         with self._lock:
@@ -92,9 +102,17 @@ class SessionManager:
             for key, value in updates.items():
                 setattr(candidate, key, value)
             self._validate_config(candidate, exclude_id=session_id)
+            old_log_messages = cfg.log_messages
+            old_durable = cfg.durable_seqnums
             for key, value in updates.items():
                 setattr(cfg, key, value)
+            if cfg.log_messages != old_log_messages:
+                session.rebind_message_log()
         self._persist()  # disk I/O — outside the lock
+        if cfg.durable_seqnums != old_durable:
+            store_path = os.path.abspath(
+                os.path.join(cfg.file_store_path, session_id))
+            shutil.rmtree(store_path, ignore_errors=True)
         return cfg
 
     async def remove_session(self, session_id: str) -> None: