fixtureqa 0.4.7__tar.gz → 0.4.9__tar.gz

{fixtureqa-0.4.7/fixtureqa.egg-info → fixtureqa-0.4.9}/PKG-INFO

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

{fixtureqa-0.4.7 → fixtureqa-0.4.9}/fixture/core/perf_engine.py

@@ -42,7 +42,7 @@ 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,
@@ -151,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:
@@ -198,15 +206,17 @@ class PerfRun:
             # client mode, count-bounded: external venue may never fill — bounded settle.
             deadline = time.perf_counter() + max(_GRACE_DRAIN_S,
                                                  self.config.test.scenario_timeout_ms / 1000.0)
-            while self._pending and time.perf_counter() < deadline:
+            while self._pending and time.perf_counter() < deadline and not self._stopped_by_user:
                 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()
@@ -242,7 +252,9 @@ class PerfRun:
         last_activity = time.perf_counter()
         while True:
             now = time.perf_counter()
-            if not self._pending or now >= cap:
+            # Stop pressed mid-drain must win immediately — the backlog gets
+            # 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:
@@ -316,6 +328,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
@@ -383,6 +401,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
@@ -409,6 +430,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."""
@@ -450,8 +496,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:
@@ -462,6 +510,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())
@@ -520,6 +570,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()
@@ -532,7 +590,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()
@@ -540,9 +615,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
     # ------------------------------------------------------------------
@@ -559,7 +673,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")
 
@@ -591,12 +713,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,
@@ -608,7 +734,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,
@@ -616,6 +743,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.7 → fixtureqa-0.4.9}/fixture/core/perf_models.py

@@ -57,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"
@@ -146,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")
@@ -177,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
@@ -191,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):
@@ -210,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.7 → fixtureqa-0.4.9}/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.7 → fixtureqa-0.4.9}/fixture/core/perf_stats.py

@@ -119,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
@@ -130,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,
@@ -168,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,
@@ -177,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(),
         }

{fixtureqa-0.4.7 → fixtureqa-0.4.9}/fixture/core/perf_store.py

@@ -6,6 +6,7 @@ parameter is unused.
 from __future__ import annotations
 
 import os
+import uuid
 from typing import Optional
 
 from .json_store import JsonListStore
@@ -28,8 +29,24 @@ class PerfStore(JsonListStore):
         return item["config"] if item else None
 
     def save(self, config: dict) -> str:
-        item = self.create_item("", {"name": config.get("name", ""), "config": config})
-        return item["config_id"]
+        """Upsert by name: saving a config whose name already exists overwrites
+        it in place (same config_id), so the dropdown never accumulates
+        duplicates. Pre-existing duplicates of that name are collapsed into the
+        first one. One locked load-modify-save so the find+replace is atomic."""
+        name = config.get("name", "")
+        with self._lock:
+            items = self._load("")
+            existing = [it for it in items if it.get("name") == name]
+            if existing:
+                keep = existing[0]
+                keep["config"] = config
+                items = [it for it in items if it.get("name") != name or it is keep]
+                self._save("", items)
+                return keep["config_id"]
+            item = {"name": name, "config": config, "config_id": str(uuid.uuid4())}
+            items.append(item)
+            self._save("", items)
+            return item["config_id"]
 
     def delete(self, config_id: str) -> bool:
         return self.delete_item("", config_id)