fixtureqa 0.4.21__tar.gz → 0.4.23__tar.gz

{fixtureqa-0.4.21/fixtureqa.egg-info → fixtureqa-0.4.23}/PKG-INFO

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

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/api/routers/messages.py

@@ -4,6 +4,7 @@ from typing import Annotated, Optional
 from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi.responses import StreamingResponse
 
+from ...core.message_store import MessageStore
 from ...core.models import SessionConfig
 from ...core.session_manager import SessionManager
 from ...core.user_store import User
@@ -16,6 +17,20 @@ SM = Annotated[SessionManager, Depends(get_session_manager)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
 
 
+def _to_response(e) -> MessageEntryResponse:
+    return MessageEntryResponse(
+        id=e.id,
+        direction=e.direction,
+        admin=e.admin,
+        seq_num=e.seq_num,
+        msg_type=e.msg_type,
+        msg_type_name=e.msg_type_name,
+        ts=e.timestamp.isoformat(),
+        fields={str(k): v for k, v in e.fields.items()},
+        raw=e.raw,
+    )
+
+
 @router.get("/{session_id}/messages", response_model=list[MessageEntryResponse])
 def get_messages(
     session_id: str,
@@ -44,20 +59,30 @@ def get_messages(
         before_id=before_id,
     )
 
-    return [
-        MessageEntryResponse(
-            id=e.id,
-            direction=e.direction,
-            admin=e.admin,
-            seq_num=e.seq_num,
-            msg_type=e.msg_type,
-            msg_type_name=e.msg_type_name,
-            ts=e.timestamp.isoformat(),
-            fields={str(k): v for k, v in e.fields.items()},
-            raw=e.raw,
-        )
-        for e in entries
-    ]
+    return [_to_response(e) for e in entries]
+
+
+@router.get("/{session_id}/messages/search", response_model=list[MessageEntryResponse])
+def search_messages(
+    session_id: str,
+    _cfg: OwnedSession,
+    sm: SM,
+    q: str = Query(..., min_length=1, description="substring or regex query over raw FIX"),
+    regex: bool = Query(default=False, description="treat q as a regular expression"),
+    limit: int = Query(default=1000, ge=1, le=5000),
+):
+    """Search the session's full messages.db history (not just the loaded page).
+    Matches against the raw FIX with SOH normalised to '|'. Returns the most
+    recent `limit` matches, oldest-first."""
+    writer = sm.message_writer
+    if writer is None:
+        return []  # message persistence disabled globally — nothing in messages.db
+    store = MessageStore(session_id, writer)
+    try:
+        entries = store.search_entries(q, regex=regex, limit=limit)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return [_to_response(e) for e in entries]
 
 
 @router.get("/{session_id}/messages/export")

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/message_store.py

@@ -12,6 +12,7 @@ inserts so the I/O thread is never blocked by SQLite.
 import json
 import logging
 import queue
+import re
 import sqlite3
 import threading
 from concurrent.futures import Future
@@ -78,6 +79,12 @@ def _entry_to_row(session_id: str, entry: LogEntry) -> tuple:
     )
 
 
+def _like_escape(s: str) -> str:
+    """Escape LIKE wildcards so a substring query matches literally (paired
+    with ESCAPE '\\' in the SQL)."""
+    return s.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
 def _row_to_entry(row) -> LogEntry:
     row_id, _, ts, direction, admin, seq_num, mt, mt_name, raw, fields_json = row
     return LogEntry(
@@ -364,6 +371,56 @@ class MessageStore:
 
         return [_row_to_entry(r) for r in rows]
 
+    def search_entries(
+        self,
+        query: str,
+        *,
+        regex: bool = False,
+        limit: int = 1000,
+    ) -> list[LogEntry]:
+        """Search this session's persisted messages by raw content — the whole
+        messages.db history for the session, not just a loaded page.
+
+        The haystack is the raw FIX with SOH normalised to '|' (so a typed
+        'tag=value' matches and the pattern lines up with the on-screen view).
+        text mode: case-insensitive substring via LIKE. regex mode: Python re
+        (case-insensitive) via a per-connection REGEXP function. Returns up to
+        `limit` most-recent matches, oldest-first. Raises ValueError on an
+        invalid regex (the route maps it to a 400)."""
+        query = query.strip()
+        if not query:
+            return []
+
+        hay = "replace(raw, char(1), '|')"
+        select = (
+            "SELECT id, session_id, ts, direction, admin, seq_num, "
+            "msg_type, msg_type_name, raw, fields_json FROM messages "
+            "WHERE session_id = ?"
+        )
+        params: list = [self._session_id]
+
+        with closing(_connect(self._db_path)) as conn:
+            if regex:
+                try:
+                    rx = re.compile(query, re.IGNORECASE)
+                except re.error as e:
+                    raise ValueError(f"invalid regex: {e}") from e
+                conn.create_function(
+                    "re_match", 1,
+                    lambda v: 1 if v is not None and rx.search(v) else 0,
+                    deterministic=True,
+                )
+                cond = f"re_match({hay})"
+            else:
+                cond = f"{hay} LIKE ? ESCAPE '\\'"
+                params.append(f"%{_like_escape(query)}%")
+            sql = (f"SELECT * FROM ({select} AND {cond} ORDER BY id DESC LIMIT ?) "
+                   "ORDER BY id ASC")
+            params.append(limit)
+            rows = conn.execute(sql, params).fetchall()
+
+        return [_row_to_entry(r) for r in rows]
+
     def __len__(self) -> int:
         with closing(_connect(self._db_path)) as conn:
             row = conn.execute(

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/models.py

@@ -108,3 +108,8 @@ class SessionState:
     message_log: Optional[MessageLog] = field(default=None)  # set by Session on init
     status_changed_at: Optional[float] = None  # time.time() of last status transition
     last_heartbeat_at: Optional[float] = None  # time.time() of last inbound Heartbeat
+    # >0 while one or more perf runs drive this session: the run generates its
+    # own acks/fills, so venue auto-responses must stay silent to avoid
+    # duplicate/conflicting ExecReports corrupting the measurement. Counter (not
+    # bool) so overlapping runs nest. Runtime-only — never persisted.
+    perf_active: int = 0

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/perf_engine.py

@@ -232,8 +232,10 @@ class PerfRun:
                 "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)
+            self._sm.mark_perf_active(self.config.client_session_id)
         if self._has_venue:
             self._venue_sub = self._sm.subscribe_session(self.config.venue_session_id)
+            self._sm.mark_perf_active(self.config.venue_session_id)
         self._writer.write_run(self._run_record())
         self._main = asyncio.create_task(self._run())
 
@@ -296,8 +298,10 @@ class PerfRun:
         self._venue_sends.clear()
         if self._client_sub:
             self._client_sub.close()
+            self._sm.unmark_perf_active(self.config.client_session_id)
         if self._venue_sub:
             self._venue_sub.close()
+            self._sm.unmark_perf_active(self.config.venue_session_id)
         if self._latency_csv is not None:
             # Correlator is cancelled (no more enqueues); drain + gzip-finalize
             # off-loop — close() joins the writer thread.
@@ -397,8 +401,19 @@ class PerfRun:
         self._finalize(entry, "dropped")
         return True
 
+    async def _send(self, session_id: str, msg: Message) -> bool:
+        """Single send path — tallies every outbound app message per leg
+        (type-agnostic) for the messages-per-second chart, then delegates."""
+        ok = await self._sm.send_message(session_id, msg)
+        if ok:
+            if session_id == self.config.client_session_id:
+                self.stats.msgs_sent_client += 1
+            else:
+                self.stats.msgs_sent_venue += 1
+        return ok
+
     async def _send_order(self, corr: str, msg: Message) -> bool:
-        ok = await self._sm.send_message(self.config.client_session_id, msg)
+        ok = await self._send(self.config.client_session_id, msg)
         if ok:
             self.stats.orders_sent += 1
         else:
@@ -493,6 +508,8 @@ class PerfRun:
         sub = self._venue_sub
         while True:
             inb = await sub.get()
+            if not inb.admin:
+                self.stats.msgs_recv_venue += 1
             recv_ns = inb.recv_perf_ns or time.perf_counter_ns()
             if inb.msg_type == "G":
                 await self._handle_amend(inb.fields, recv_ns)
@@ -517,7 +534,7 @@ class PerfRun:
                                  last_qty=0, cum_qty=0, leaves_qty=order_qty, px="0")
                 if ack is not None:
                     send_ns = time.perf_counter_ns()
-                    if await self._sm.send_message(cfg.venue_session_id, ack):
+                    if await self._send(cfg.venue_session_id, ack):
                         self.stats.acks_sent += 1
                         self._register_venue_send(ack, "ack", corr, of.get(T_CLORDID), send_ns)
 
@@ -573,7 +590,7 @@ class PerfRun:
                             cum_qty=cum_qty, leaves_qty=leaves_qty, px=entry["px"])
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self.stats.fills_sent += 1
                     self._register_venue_send(er, "fill", corr,
                                               entry["of"].get(T_CLORDID), send_ns)
@@ -647,14 +664,14 @@ class PerfRun:
                                   orig_clordid=orig)
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self._register_venue_send(er, "pending-replace", corr, clordid, send_ns)
         er = self._build_exec(of, exec_type="5", ord_status="5", last_qty=0,
                               cum_qty=cum, leaves_qty=leaves, px=px,
                               orig_clordid=orig)
         if er is not None:
             send_ns = time.perf_counter_ns()
-            if await self._sm.send_message(cfg.venue_session_id, er):
+            if await self._send(cfg.venue_session_id, er):
                 self._register_venue_send(er, "replace", corr, clordid, send_ns)
 
     async def _handle_cancel(self, of: dict, recv_ns: int = 0) -> None:
@@ -691,12 +708,12 @@ class PerfRun:
                                   orig_clordid=of.get(T_ORIGCLORDID))
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self._register_venue_send(er, "canceled", corr, clordid, send_ns)
             return
         msg = self._build_cancel_reject(of, entry)
         send_ns = time.perf_counter_ns()
-        if await self._sm.send_message(cfg.venue_session_id, msg):
+        if await self._send(cfg.venue_session_id, msg):
             self._register_venue_send(msg, "cancel-reject", corr, clordid, send_ns)
 
     def _build_cancel_reject(self, of: dict, entry: Optional[dict]) -> Message:
@@ -811,6 +828,8 @@ class PerfRun:
         sub = self._client_sub
         while True:
             inb = await sub.get()
+            if not inb.admin:
+                self.stats.msgs_recv_client += 1
             if inb.msg_type == "9":
                 self._on_cancel_reject(inb.fields, inb.recv_perf_ns or time.perf_counter_ns())
                 continue
@@ -998,7 +1017,7 @@ class PerfRun:
         entry["cancel_clordid"] = new_clordid
         entry["cancel_sent_ns"] = time.perf_counter_ns()
         entry["cancel_sent_at"] = time.time()
-        if await self._sm.send_message(self.config.client_session_id, msg):
+        if await self._send(self.config.client_session_id, msg):
             self.stats.cancels_sent += 1
         else:
             entry["cancel_inflight"] = False
@@ -1129,7 +1148,7 @@ class PerfRun:
         entry["amends_sent"] = n + 1
         entry["amend_sent_ns"] = time.perf_counter_ns()
         entry["amend_sent_at"] = time.time()
-        if await self._sm.send_message(self.config.client_session_id, msg):
+        if await self._send(self.config.client_session_id, msg):
             self.stats.amends_sent += 1
         else:
             entry["amend_inflight"] = False
@@ -1219,6 +1238,8 @@ class PerfRun:
                 cps_live=round(r.cps, 1),
                 crps_live=round(r.crps, 1),
                 ccps_live=round(r.ccps, 1),
+                msgs_out_live=round(r.mco, 1),
+                msgs_in_live=round(r.mci, 1),
                 scenarios_dispatched=self.stats.scenarios_dispatched,
                 scenarios_per_sec=round(r.sps, 1),
                 scenarios_completed=self.stats.scenarios_completed,
@@ -1235,7 +1256,9 @@ class PerfRun:
                 amends_uncorrelated=self.stats.amends_uncorrelated,
                 amend_waits_expired=self.stats.amend_waits_expired,
                 cancels_received=self.stats.cancels_received,
-                cancels_uncorrelated=self.stats.cancels_uncorrelated)
+                cancels_uncorrelated=self.stats.cancels_uncorrelated,
+                msgs_out_live=round(r.mvo, 1),
+                msgs_in_live=round(r.mvi, 1))
         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,

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/perf_models.py

@@ -252,6 +252,8 @@ class ClientLeg(BaseModel):
     cps_live: float = 0.0
     crps_live: float = 0.0
     ccps_live: float = 0.0
+    msgs_out_live: float = 0.0   # all app messages this leg sent/s (MPS chart)
+    msgs_in_live: float = 0.0    # all app messages this leg received/s
     scenarios_dispatched: int = 0
     scenarios_per_sec: float = 0.0
     scenarios_completed: int = 0
@@ -271,6 +273,8 @@ class VenueLeg(BaseModel):
     amend_waits_expired: int = 0
     cancels_received: int = 0
     cancels_uncorrelated: int = 0
+    msgs_out_live: float = 0.0   # all app messages this leg sent/s (MPS chart)
+    msgs_in_live: float = 0.0    # all app messages this leg received/s
 
 
 class SnapshotErrors(BaseModel):

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/perf_stats.py

@@ -25,6 +25,12 @@ class Rates(NamedTuple):
     cps: float    # cancels sent/s (35=F)
     crps: float   # cancel-rejects received/s (35=9)
     ccps: float   # canceled received/s (150=4)
+    # Type-agnostic message rates (every app message sent/received per leg) for
+    # the messages-per-second chart — counts all kinds, so it can't drift.
+    mco: float    # client leg messages sent/s   (orders + amends + cancels …)
+    mci: float    # client leg messages received/s (acks + fills + replies …)
+    mvo: float    # venue leg messages sent/s    (acks + fills + replies …)
+    mvi: float    # venue leg messages received/s (orders + amends + cancels …)
 
 
 class TokenBucket:
@@ -147,6 +153,11 @@ class PerfStats:
         self.cancels_received = 0    # venue saw an inbound 35=F
         self.cancels_uncorrelated = 0  # inbound 35=F lacked the correlation tag (no reply)
         self.venue_sends_unmatched = 0  # one-way send records evicted w/o a matching recv
+        # Type-agnostic per-leg message tallies (every app message), for the MPS chart.
+        self.msgs_sent_client = 0
+        self.msgs_recv_client = 0
+        self.msgs_sent_venue = 0
+        self.msgs_recv_venue = 0
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0
@@ -170,6 +181,10 @@ class PerfStats:
         self._last_cancels = 0
         self._last_cancel_rejects = 0
         self._last_canceled = 0
+        self._last_msc = 0
+        self._last_mrc = 0
+        self._last_msv = 0
+        self._last_mrv = 0
 
     def rates(self) -> Rates:
         """Per-second deltas since the last call. Stateful — call exactly once
@@ -177,7 +192,7 @@ class PerfStats:
         now = time.monotonic()
         dt = now - self._last_t
         if dt <= 0:
-            return Rates(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+            return Rates(*([0.0] * 11))
         r = Rates(
             ops=(self.orders_sent - self._last_orders) / dt,
             fps=(self.fills_sent - self._last_fills) / dt,
@@ -186,6 +201,10 @@ class PerfStats:
             cps=(self.cancels_sent - self._last_cancels) / dt,
             crps=(self.cancel_rejects - self._last_cancel_rejects) / dt,
             ccps=(self.cancels_canceled - self._last_canceled) / dt,
+            mco=(self.msgs_sent_client - self._last_msc) / dt,
+            mci=(self.msgs_recv_client - self._last_mrc) / dt,
+            mvo=(self.msgs_sent_venue - self._last_msv) / dt,
+            mvi=(self.msgs_recv_venue - self._last_mrv) / dt,
         )
         self._last_t = now
         self._last_orders = self.orders_sent
@@ -195,6 +214,10 @@ class PerfStats:
         self._last_cancels = self.cancels_sent
         self._last_cancel_rejects = self.cancel_rejects
         self._last_canceled = self.cancels_canceled
+        self._last_msc = self.msgs_sent_client
+        self._last_mrc = self.msgs_recv_client
+        self._last_msv = self.msgs_sent_venue
+        self._last_mrv = self.msgs_recv_venue
         return r
 
     def fill_ratio(self) -> float:

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/session.py

@@ -286,8 +286,12 @@ class Session:
                 self.state.last_recv_seq_num = entry.seq_num
                 if entry.msg_type == "0":  # Heartbeat
                     self.state.last_heartbeat_at = time.time()
+                # Stay silent while a perf run drives this session — the run
+                # generates its own acks/fills, so an auto-response here would
+                # double up and corrupt the measurement.
                 if (entry.msg_type == "D" and not entry.admin
-                        and self.config.session_role.value == "venue"):
+                        and self.config.session_role.value == "venue"
+                        and self.state.perf_active == 0):
                     self._schedule_venue_responses(entry.fields)
 
         self._event_handler(event)

{fixtureqa-0.4.21 → fixtureqa-0.4.23}/fixture/core/session_manager.py

@@ -223,6 +223,23 @@ class SessionManager:
                 if not subs:
                     self._session_subs.pop(sub.session_id, None)
 
+    def mark_perf_active(self, session_id: str) -> None:
+        """A perf run started driving this session — suppress its venue
+        auto-responses (the run owns the acks/fills) until unmarked. Counter,
+        so overlapping runs nest. Mirror with unmark_perf_active()."""
+        with self._lock:
+            session = self._sessions.get(session_id)
+        if session is not None:
+            session.state.perf_active += 1
+
+    def unmark_perf_active(self, session_id: str) -> None:
+        """A perf run stopped driving this session. Tolerates a session removed
+        mid-run (lookup may miss) and never underflows below zero."""
+        with self._lock:
+            session = self._sessions.get(session_id)
+        if session is not None:
+            session.state.perf_active = max(0, session.state.perf_active - 1)
+
     # ------------------------------------------------------------------
     # Internal
     # ------------------------------------------------------------------