fixtureqa 0.4.6__tar.gz → 0.4.8__tar.gz

{fixtureqa-0.4.6/fixtureqa.egg-info → fixtureqa-0.4.8}/PKG-INFO

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

{fixtureqa-0.4.6 → fixtureqa-0.4.8}/fixture/core/perf_engine.py

@@ -35,14 +35,14 @@ from .perf_models import (
     RunConfig, RunStatus, LiveSnapshot, ClientLeg, VenueLeg, SnapshotErrors, LatencyStats,
 )
 from .perf_payload import PayloadFactory, ScenarioSelector
-from .perf_stats import PerfStats, TokenBucket
+from .perf_stats import BurstGate, PerfStats, TokenBucket
 from .perf_writer import PerfWriter
 from .session_manager import SessionManager
 
 logger = logging.getLogger(__name__)
 
 # FIX tags
-T_MSGTYPE, T_CLORDID, T_SYMBOL, T_SIDE = 35, 11, 55, 54
+T_MSGTYPE, T_CLORDID, T_ORIGCLORDID, T_SYMBOL, T_SIDE = 35, 11, 41, 55, 54
 T_ORDERQTY, T_ORDTYPE, T_PRICE, T_TIF, T_TRANSACTTIME = 38, 40, 44, 59, 60
 T_ORDERID, T_EXECID, T_EXECTRANSTYPE, T_EXECTYPE, T_ORDSTATUS = 37, 17, 20, 150, 39
 T_LASTQTY, T_LASTPX, T_CUMQTY, T_LEAVESQTY, T_AVGPX = 32, 31, 14, 151, 6
@@ -107,6 +107,10 @@ class PerfRun:
         self._pending: dict[str, dict] = {}
         self._order_seq = 0
 
+        # Amend injection is fill-triggered on the client leg (35=D orders only).
+        self._amend_on = config.amend.enabled and self._has_client
+        self._amend_tasks: set[asyncio.Task] = set()
+
         # PayloadFactory validates templates/tokens now — raises PerfConfigError
         # (surfaced as 422) before any task starts.
         self._factory = PayloadFactory(config, template_store, owner_uid,
@@ -115,10 +119,15 @@ class PerfRun:
                           if config.payload.scenarios else None)
 
         r = config.rate
-        self._order_bucket = TokenBucket(r.orders_per_window, r.order_window_ms,
-                                         r.allow_burst, r.max_burst_multiplier)
-        self._fill_bucket = TokenBucket(r.fills_per_window, r.fill_window_ms,
-                                        r.allow_burst, r.max_burst_multiplier)
+
+        def _pacer(per_window: int, window_ms: int, mode: str):
+            if mode == "burst":
+                return BurstGate(per_window, window_ms)
+            return TokenBucket(per_window, window_ms,
+                               r.allow_burst, r.max_burst_multiplier)
+
+        self._order_bucket = _pacer(r.orders_per_window, r.order_window_ms, r.dispatch)
+        self._fill_bucket = _pacer(r.fills_per_window, r.fill_window_ms, r.fill_dispatch)
 
         self._client_sub = None
         self._venue_sub = None
@@ -146,6 +155,10 @@ class PerfRun:
             else:
                 self._exec_csv = ExecCsvWriter(
                     os.path.join(self._execs_dir, f"{self.run_id}.csv.gz"))
+        if self.config.amend.enabled and not self._has_client:
+            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._has_client:
             self._client_sub = self._sm.subscribe_session(self.config.client_session_id)
         if self._has_venue:
@@ -197,11 +210,13 @@ class PerfRun:
                 await asyncio.sleep(0.02)
         else:
             await asyncio.sleep(_GRACE_DRAIN_S)
-        for t in self._tasks:
+        for t in list(self._tasks) + list(self._amend_tasks):
             t.cancel()
-        await asyncio.gather(*self._tasks, return_exceptions=True)
+        await asyncio.gather(*self._tasks, *self._amend_tasks, return_exceptions=True)
         for entry in list(self._pending.values()):
-            self._finalize(entry, "lost")
+            if entry.get("amend_inflight"):
+                self.stats.amends_lost += 1
+            self._finalize(entry, "filled" if entry.get("completed") else "lost")
         self._pending.clear()
         if self._client_sub:
             self._client_sub.close()
@@ -311,6 +326,12 @@ class PerfRun:
         meta["sent_at"] = time.time()
         meta["responded"] = False
         meta["seen_exec"] = set()
+        if self._amend_on and meta.get("msg_type") == "D":
+            meta["amend_eligible"] = random.random() < self.config.amend.amend_ratio
+            meta["fills_seen"] = 0
+            meta["amends_sent"] = 0
+            meta["amend_inflight"] = False
+            meta["completed"] = False
         if resp_event is not None:
             meta["resp_event"] = resp_event
         self._pending[meta["corr_id"]] = meta
@@ -378,6 +399,9 @@ class PerfRun:
         sub = self._venue_sub
         while True:
             inb = await sub.get()
+            if inb.msg_type == "G":
+                await self._handle_amend(inb.fields)
+                continue
             if inb.msg_type != "D":
                 continue
             self.stats.orders_received += 1
@@ -404,6 +428,31 @@ class PerfRun:
                 if er is not None and await self._sm.send_message(cfg.venue_session_id, er):
                     self.stats.fills_sent += 1
 
+    async def _handle_amend(self, of: dict) -> None:
+        """Venue side of 35=G: reply Replaced (150=5/39=5), optionally preceded
+        by Pending Replace (150=E/39=E). Stateless — built from the request's
+        own fields with no order book, so CumQty reads 0 even when the order is
+        partially filled (the OMS under test reads 150/39 + the ClOrdID chain).
+        Like acks, replies are immediate, not fill-rate-limited."""
+        cfg = self.config
+        self.stats.amends_received += 1
+        if of.get(cfg.correlation_tag) is None:
+            return
+        order_qty = _to_int(of.get(T_ORDERQTY), 0)
+        px = of.get(T_PRICE) or "0"
+        orig = of.get(T_ORIGCLORDID)
+        if cfg.amend.pending_replace:
+            er = self._build_exec(of, exec_type="E", ord_status="E", last_qty=0,
+                                  cum_qty=0, leaves_qty=order_qty, px=px,
+                                  orig_clordid=orig)
+            if er is not None:
+                await self._sm.send_message(cfg.venue_session_id, er)
+        er = self._build_exec(of, exec_type="5", ord_status="5", last_qty=0,
+                              cum_qty=0, leaves_qty=order_qty, px=px,
+                              orig_clordid=orig)
+        if er is not None:
+            await self._sm.send_message(cfg.venue_session_id, er)
+
     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."""
@@ -445,8 +494,10 @@ class PerfRun:
         return schedule
 
     def _build_exec(self, of: dict, *, exec_type: str, ord_status: str,
-                    last_qty: int, cum_qty: int, leaves_qty: int, px: str) -> Optional[Message]:
-        """Build one ExecutionReport (ack or fill) from an inbound order's fields."""
+                    last_qty: int, cum_qty: int, leaves_qty: int, px: str,
+                    orig_clordid: Optional[str] = None) -> Optional[Message]:
+        """Build one ExecutionReport (ack, fill or replace ack) from an inbound
+        message's fields."""
         cfg = self.config
         corr = of.get(cfg.correlation_tag)
         if corr is None:
@@ -457,6 +508,8 @@ class PerfRun:
         er.header.set(T_MSGTYPE, "8")
         if of.get(T_CLORDID):
             er.set_field(T_CLORDID, of[T_CLORDID])
+        if orig_clordid:
+            er.set_field(T_ORIGCLORDID, orig_clordid)
         er.set_field(cfg.correlation_tag, corr)
         er.set_field(cfg.exec_id_tag, _uuid())
         er.set_field(T_ORDERID, "O" + _guid()[:8].upper())
@@ -515,6 +568,14 @@ 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.
+        exec_type = f.get(T_EXECTYPE)
+        if exec_type in ("E", "5"):
+            if exec_type == "5":
+                self._on_replaced(corr, entry, now_ns)
+            return
+
         if not entry["responded"]:
             entry["responded"] = True
             entry["first_resp_at"] = time.time()
@@ -527,7 +588,24 @@ class PerfRun:
                 ev.set()
 
         cum = _to_int(f.get(T_CUMQTY), 0)
-        if cum >= entry["order_qty"]:
+
+        # 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):
+            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)
+
+        if cum >= entry["order_qty"] and not entry.get("completed"):
             lat_us = (now_ns - entry["sent_ns"]) / 1000.0
             entry["fill_latency_us"] = lat_us
             entry["filled_at"] = time.time()
@@ -535,9 +613,48 @@ 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.
+                entry["completed"] = True
+            else:
+                entry["completed"] = True
+                self._pending.pop(corr, None)
+                self._finalize(entry, "filled")
+
+    def _on_replaced(self, corr: str, entry: dict, now_ns: int) -> None:
+        """Client got a Replaced ack (150=5): close the in-flight amend."""
+        self.stats.replaces_received += 1
+        sent_ns = entry.get("amend_sent_ns")
+        if entry.get("amend_inflight") and sent_ns:
+            self.stats.amend_latency.add((now_ns - sent_ns) / 1000.0)
+        if entry.get("pending_clordid"):
+            entry["clordid"] = entry["pending_clordid"]
+            entry["pending_clordid"] = None
+        entry["amend_inflight"] = False
+        if entry.get("completed"):
             self._pending.pop(corr, None)
             self._finalize(entry, "filled")
 
+    async def _send_amend(self, entry: dict) -> None:
+        """Build and send one price amend (alternating ± offset). Demand-driven
+        by fills (rate ≈ fills/s ÷ every_n_fills) — no pacer of its own."""
+        a = self.config.amend
+        n = entry["amends_sent"]
+        base = _to_float(entry.get("price")) or 100.0
+        new_price = round(base + a.price_offset * (1 if n % 2 == 0 else -1), 4)
+        msg, new_clordid = self._factory.build_amend(entry, new_price)
+        entry["pending_clordid"] = new_clordid
+        entry["amends_sent"] = n + 1
+        entry["amend_sent_ns"] = time.perf_counter_ns()
+        if await self._sm.send_message(self.config.client_session_id, msg):
+            self.stats.amends_sent += 1
+        else:
+            entry["amend_inflight"] = False
+            entry["pending_clordid"] = None
+
     # ------------------------------------------------------------------
     # Timeout sweeper
     # ------------------------------------------------------------------
@@ -554,7 +671,15 @@ class PerfRun:
             expired = [c for c, e in self._pending.items() if now - e["sent_ns"] > timeout_ns]
             for c in expired:
                 entry = self._pending.pop(c, None)
-                if entry is not None:
+                if entry is None:
+                    continue
+                if entry.get("amend_inflight"):
+                    self.stats.amends_lost += 1
+                if entry.get("completed"):
+                    # Order filled; only the amend's Replaced ack never came —
+                    # don't double-count a completed order as lost.
+                    self._finalize(entry, "filled")
+                else:
                     self.stats.lost_timeout += 1
                     self._finalize(entry, "lost")
 
@@ -586,12 +711,16 @@ class PerfRun:
         return (time.perf_counter_ns() - self._start_ns) / 1e9 if self._start_ns else 0.0
 
     def _build_snapshot(self) -> None:
-        ops, fps, sps = self.stats.rates()
+        ops, fps, sps, aps = self.stats.rates()
         client = None
         if self._has_client:
             client = ClientLeg(
                 orders_sent=self.stats.orders_sent, ops_live=round(ops, 1),
                 pending=len(self._pending), dropped=self.stats.dropped,
+                amends_sent=self.stats.amends_sent,
+                replaces_received=self.stats.replaces_received,
+                amends_lost=self.stats.amends_lost,
+                aps_live=round(aps, 1),
                 scenarios_dispatched=self.stats.scenarios_dispatched,
                 scenarios_per_sec=round(sps, 1),
                 scenarios_completed=self.stats.scenarios_completed,
@@ -603,7 +732,8 @@ class PerfRun:
                 acks_sent=self.stats.acks_sent,
                 fills_sent=self.stats.fills_sent, fps_live=round(fps, 1),
                 fill_ratio=round(self.stats.fill_ratio(), 3),
-                unfilled=max(0, self.stats.orders_sent - self.stats.completions))
+                unfilled=max(0, self.stats.orders_sent - self.stats.completions),
+                amends_received=self.stats.amends_received)
         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,
@@ -611,6 +741,7 @@ class PerfRun:
             client=client, venue=venue,
             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()),
             scenario_latency=LatencyStats(**self.stats.scenario_latency.stats()),
             errors=SnapshotErrors(lost_timeout=self.stats.lost_timeout,
                                   rejected=self.stats.rejected,

{fixtureqa-0.4.6 → fixtureqa-0.4.8}/fixture/core/perf_models.py

@@ -24,9 +24,17 @@ RunState = Literal["pending", "running", "completed", "stopped", "error", "satur
 Sequence = Literal["parallel", "sequential", "sequential_timed"]
 
 
+DispatchMode = Literal["smooth", "burst"]
+
+
 class RateConfig(BaseModel):
     orders_per_window: int = Field(gt=0)
     order_window_ms: int = Field(gt=0)
+    # smooth: continuous-refill token bucket — sends evenly spaced at the
+    # average rate. burst: up to per_window sends back-to-back per window
+    # boundary, then silence until the next window (sawtooth throughput).
+    dispatch: DispatchMode = "smooth"        # order leg
+    fill_dispatch: DispatchMode = "smooth"   # venue exec leg
     fills_per_window: int = Field(gt=0)
     fill_window_ms: int = Field(gt=0)
     fill_ratio: float = Field(default=1.0, ge=0.0, le=1.0)
@@ -49,6 +57,24 @@ class TestConfig(BaseModel):
     record_execs: bool = False
 
 
+class AmendConfig(BaseModel):
+    """Client-leg amend traffic (35=G OrderCancelReplaceRequest), price-only.
+
+    Triggered every `every_n_fills` fills of a working order (so amend rate ≈
+    fills/s ÷ n); `amend_ratio` picks the eligible fraction of orders and
+    `max_per_order` caps the chain length (0 = unlimited). Each amend nudges
+    the price by ± `price_offset` (alternating). `pending_replace` makes the
+    in-process venue reply 150=E (Pending Replace) before 150=5 (Replaced),
+    matching common real-venue behaviour. Amends never fire on the final fill
+    — use partial fills or fills_per_order > 1 to leave the order working."""
+    enabled: bool = False
+    every_n_fills: int = Field(default=1, ge=1)
+    amend_ratio: float = Field(default=1.0, ge=0.0, le=1.0)
+    max_per_order: int = Field(default=1, ge=0)
+    price_offset: float = Field(default=0.01, gt=0)
+    pending_replace: bool = False
+
+
 class OrderPayloadConfig(BaseModel):
     symbols: list[str] = Field(min_length=1)
     side: Literal["fixed_buy", "fixed_sell", "alternate", "random"] = "alternate"
@@ -138,6 +164,7 @@ class RunConfig(BaseModel):
     exec_id_tag: int = Field(default=25116, gt=0)
     rate: RateConfig
     test: TestConfig = Field(default_factory=TestConfig)
+    amend: AmendConfig = Field(default_factory=AmendConfig)
     payload: PayloadConfig
 
     @model_validator(mode="after")
@@ -169,6 +196,10 @@ class ClientLeg(BaseModel):
     ops_live: float = 0.0
     pending: int = 0
     dropped: int = 0
+    amends_sent: int = 0
+    replaces_received: int = 0
+    amends_lost: int = 0
+    aps_live: float = 0.0
     scenarios_dispatched: int = 0
     scenarios_per_sec: float = 0.0
     scenarios_completed: int = 0
@@ -183,6 +214,7 @@ class VenueLeg(BaseModel):
     fill_ratio: float = 0.0
     unfilled: int = 0
     venue_proc_us_p50: float = 0.0
+    amends_received: int = 0
 
 
 class SnapshotErrors(BaseModel):
@@ -202,6 +234,7 @@ class LiveSnapshot(BaseModel):
     venue: Optional[VenueLeg] = None
     response_latency: LatencyStats = Field(default_factory=LatencyStats)
     fill_completion_latency: LatencyStats = Field(default_factory=LatencyStats)
+    amend_latency: LatencyStats = Field(default_factory=LatencyStats)
     scenario_latency: LatencyStats = Field(default_factory=LatencyStats)
     errors: SnapshotErrors = Field(default_factory=SnapshotErrors)
 

{fixtureqa-0.4.6 → fixtureqa-0.4.8}/fixture/core/perf_payload.py

@@ -385,6 +385,29 @@ class PayloadFactory:
     def _clordid(self) -> str:
         return "PCL-" + _guid()[:12].upper()
 
+    # -- amend (35=G OrderCancelReplaceRequest, price-only) -------------
+
+    def build_amend(self, meta: dict, new_price: float) -> tuple[Message, str]:
+        """Re-price a working order. Carries the order's correlation id so the
+        replace acks route to the same pending entry; OrigClOrdID(41) is the
+        current chain tip, ClOrdID(11) is fresh — returned so the engine can
+        promote the chain once the venue confirms (150=5)."""
+        p = self.config.payload.order
+        new_clordid = self._clordid()
+        msg = Message()
+        msg.header.set(35, "G")
+        msg.set_field(11, new_clordid)
+        msg.set_field(41, meta["clordid"])
+        msg.set_field(self.config.correlation_tag, meta["corr_id"])
+        msg.set_field(55, meta["symbol"])
+        msg.set_field(54, meta["side"])
+        msg.set_field(38, str(meta["order_qty"]))
+        msg.set_field(40, "2")   # re-pricing → limit, whatever the original was
+        msg.set_field(44, f"{new_price:.2f}")
+        msg.set_field(59, p.time_in_force)
+        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.6 → fixtureqa-0.4.8}/fixture/core/perf_stats.py

@@ -40,6 +40,34 @@ class TokenBucket:
             await asyncio.sleep((n - self._tokens) / self._rate_per_s)
 
 
+class BurstGate:
+    """Window-boundary pacer (same `acquire()` contract as TokenBucket).
+
+    Allows `per_window` acquires back-to-back within each window, then blocks
+    everyone until the next boundary — a sawtooth instead of the bucket's even
+    spacing. Boundaries stay aligned to the original cadence (no drift).
+    Note: it shapes a ceiling — bursts only show when demand inside a window
+    exceeds it (e.g. injector loop, or a venue fill backlog)."""
+
+    def __init__(self, per_window: int, window_ms: int):
+        self._per_window = per_window
+        self._window_s = window_ms / 1000.0
+        self._window_end = time.monotonic() + self._window_s
+        self._used = 0
+
+    async def acquire(self, n: int = 1) -> None:
+        while True:
+            now = time.monotonic()
+            if now >= self._window_end:
+                missed = int((now - self._window_end) / self._window_s) + 1
+                self._window_end += missed * self._window_s
+                self._used = 0
+            if self._used + n <= self._per_window:
+                self._used += n
+                return
+            await asyncio.sleep(max(0.0, self._window_end - now))
+
+
 class _Reservoir:
     """Reservoir sampler over latency values (microseconds). Exact count/mean/max;
     approximate percentiles from a fixed-size representative sample."""
@@ -91,6 +119,10 @@ class PerfStats:
         self.fills_sent = 0          # venue sent a fill ExecutionReport
         self.responses = 0           # client got first response for an order
         self.completions = 0         # client saw a full fill
+        self.amends_sent = 0         # client sent a 35=G
+        self.replaces_received = 0   # client got a Replaced ack (150=5)
+        self.amends_lost = 0         # amend in flight when its order was reaped
+        self.amends_received = 0     # venue saw an inbound 35=G
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0
@@ -102,27 +134,31 @@ class PerfStats:
 
         self.response_latency = _Reservoir(reservoir_size)
         self.fill_completion_latency = _Reservoir(reservoir_size)
+        self.amend_latency = _Reservoir(reservoir_size)
         self.scenario_latency = _Reservoir(reservoir_size)
 
         self._last_t = time.monotonic()
         self._last_orders = 0
         self._last_fills = 0
         self._last_scen = 0
+        self._last_amends = 0
 
-    def rates(self) -> tuple[float, float, float]:
-        """(orders/s, fills/s, scenarios/s) since the last call (delta-based)."""
+    def rates(self) -> tuple[float, float, float, float]:
+        """(orders/s, fills/s, scenarios/s, amends/s) since the last call (delta-based)."""
         now = time.monotonic()
         dt = now - self._last_t
         if dt <= 0:
-            return 0.0, 0.0, 0.0
+            return 0.0, 0.0, 0.0, 0.0
         ops = (self.orders_sent - self._last_orders) / dt
         fps = (self.fills_sent - self._last_fills) / dt
         sps = (self.scenarios_dispatched - self._last_scen) / dt
+        aps = (self.amends_sent - self._last_amends) / dt
         self._last_t = now
         self._last_orders = self.orders_sent
         self._last_fills = self.fills_sent
         self._last_scen = self.scenarios_dispatched
-        return ops, fps, sps
+        self._last_amends = self.amends_sent
+        return ops, fps, sps, aps
 
     def fill_ratio(self) -> float:
         # Fraction of orders fully filled (cumQty >= orderQty). Uses completions,
@@ -140,6 +176,10 @@ class PerfStats:
             "fills_sent": self.fills_sent,
             "responses": self.responses,
             "completions": self.completions,
+            "amends_sent": self.amends_sent,
+            "replaces_received": self.replaces_received,
+            "amends_lost": self.amends_lost,
+            "amends_received": self.amends_received,
             "lost_timeout": self.lost_timeout,
             "dropped": self.dropped,
             "rejected": self.rejected,
@@ -149,5 +189,6 @@ class PerfStats:
             "fill_ratio": self.fill_ratio(),
             "response_latency": self.response_latency.stats(),
             "fill_completion_latency": self.fill_completion_latency.stats(),
+            "amend_latency": self.amend_latency.stats(),
             "scenario_latency": self.scenario_latency.stats(),
         }