fixtureqa 0.12.1__tar.gz → 0.14.0__tar.gz

{fixtureqa-0.12.1/fixtureqa.egg-info → fixtureqa-0.14.0}/PKG-INFO

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

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/api/app.py

@@ -35,6 +35,11 @@ async def lifespan(app: FastAPI):
     # Register event bridge with SessionManager
     sm: SessionManager = app.state.session_manager
     cm: ConnectionManager = app.state.connection_manager
+    # Resolve a sender's uid → username for live message frames.
+    _user_store = app.state.user_store
+    cm.set_username_resolver(
+        lambda uid: (u.username if (u := _user_store.get_by_uid(uid)) else None)
+    )
     sm.subscribe(cm.sync_event_handler)
     # Periodic WS message-rate aggregator (emits message_agg under high load)
     agg_task = asyncio.create_task(cm.run_aggregator())

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/api/connection_manager.py

@@ -8,6 +8,7 @@ import asyncio
 import json
 import logging
 from datetime import datetime, timezone
+from typing import Callable
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +46,7 @@ def _serialize_event(event: SessionEvent) -> dict:
             "ts": _now_iso(),
             "fields": {str(k): v for k, v in p.get("fields", {}).items()},
             "raw": p.get("raw", ""),
+            "user_id": p.get("user_id"),
         }
     elif event.event_type == EventType.ENGINE_ERROR:
         return {
@@ -83,6 +85,9 @@ class ConnectionManager:
         # The FastAPI/uvicorn event loop, bound in the app lifespan — needed to
         # schedule broadcasts submitted from worker threads (scenario runner).
         self._loop: asyncio.AbstractEventLoop | None = None
+        # uid -> username resolver, bound in the app lifespan. Enriches live
+        # message frames so the UI shows the sender's name, not their uid.
+        self._username_resolver: "Callable[[str], str | None] | None" = None
         # Hold strong references to in-flight broadcast tasks. asyncio only keeps
         # a weak reference to tasks, so a fire-and-forget create_task() can be
         # garbage-collected mid-execution, silently dropping a broadcast.
@@ -91,6 +96,16 @@ class ConnectionManager:
         self._counters: dict[str, dict] = {}
         self._per_window_cap = max(1, int(self.PER_MSG_RATE_CAP * self.AGG_INTERVAL_S))
 
+    def set_username_resolver(self, fn: "Callable[[str], str | None]") -> None:
+        self._username_resolver = fn
+
+    def _frame(self, event: SessionEvent) -> dict:
+        """Serialize an event, resolving a message sender's uid to a username."""
+        frame = _serialize_event(event)
+        if frame.get("type") == "message" and frame.get("user_id") and self._username_resolver:
+            frame["username"] = self._username_resolver(frame["user_id"])
+        return frame
+
     def _has_clients(self) -> bool:
         return any(self._clients.values())
 
@@ -150,10 +165,10 @@ class ConnectionManager:
             # Stream per-message only while under the per-window cap; beyond it
             # the aggregator emits a summary instead (bounded task creation).
             if c["count"] <= self._per_window_cap:
-                self._spawn(self._broadcast(sid, _serialize_event(event), event.owner_uid))
+                self._spawn(self._broadcast(sid, self._frame(event), event.owner_uid))
         else:
             # status / engine_error — always delivered immediately
-            self._spawn(self._broadcast(event.session_id, _serialize_event(event), event.owner_uid))
+            self._spawn(self._broadcast(event.session_id, self._frame(event), event.owner_uid))
 
     async def run_aggregator(self) -> None:
         """Periodic task: emit a `message_agg` summary for any session whose

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/api/routers/messages.py

@@ -7,17 +7,29 @@ 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
+from ...core.user_store import User, UserStore
 from ..schemas import MessageEntryResponse
-from ..deps import get_session_manager, get_owned_session
+from ..deps import get_session_manager, get_owned_session, get_user_store
 
 router = APIRouter(tags=["messages"])
 
 SM = Annotated[SessionManager, Depends(get_session_manager)]
+US = Annotated[UserStore, Depends(get_user_store)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
 
 
-def _to_response(e) -> MessageEntryResponse:
+def _username_map(entries, users: UserStore) -> dict[str, str]:
+    """Resolve the distinct sender uids in `entries` to usernames in one pass."""
+    uids = {e.user_id for e in entries if e.user_id}
+    out: dict[str, str] = {}
+    for uid in uids:
+        u = users.get_by_uid(uid)
+        if u is not None:
+            out[uid] = u.username
+    return out
+
+
+def _to_response(e, usernames: dict[str, str]) -> MessageEntryResponse:
     return MessageEntryResponse(
         id=e.id,
         direction=e.direction,
@@ -28,6 +40,8 @@ def _to_response(e) -> MessageEntryResponse:
         ts=e.timestamp.isoformat(),
         fields={str(k): v for k, v in e.fields.items()},
         raw=e.raw,
+        user_id=e.user_id,
+        username=usernames.get(e.user_id) if e.user_id else None,
     )
 
 
@@ -36,6 +50,7 @@ def get_messages(
     session_id: str,
     _cfg: OwnedSession,
     sm: SM,
+    users: US,
     direction: Optional[str] = Query(default=None, description="IN or OUT"),
     admin: Optional[bool] = Query(default=None),
     msg_type: Optional[str] = Query(default=None),
@@ -59,7 +74,8 @@ def get_messages(
         before_id=before_id,
     )
 
-    return [_to_response(e) for e in entries]
+    usernames = _username_map(entries, users)
+    return [_to_response(e, usernames) for e in entries]
 
 
 @router.get("/{session_id}/messages/search", response_model=list[MessageEntryResponse])
@@ -67,6 +83,7 @@ def search_messages(
     session_id: str,
     _cfg: OwnedSession,
     sm: SM,
+    users: US,
     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),
@@ -82,7 +99,8 @@ def search_messages(
         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]
+    usernames = _username_map(entries, users)
+    return [_to_response(e, usernames) for e in entries]
 
 
 @router.get("/{session_id}/messages/export")
@@ -90,6 +108,7 @@ def export_messages(
     session_id: str,
     _cfg: OwnedSession,
     sm: SM,
+    users: US,
     fmt: str = Query(default="csv", description="Export format: csv or fix"),
 ):
     try:
@@ -99,6 +118,7 @@ def export_messages(
 
     log = state.message_log
     entries = log.get_entries() if log is not None else []
+    usernames = _username_map(entries, users)
 
     safe_id = session_id.replace("/", "_")
 
@@ -117,7 +137,7 @@ def export_messages(
     def generate_csv():
         buf = io.StringIO()
         writer = csv.writer(buf)
-        writer.writerow(["id", "ts", "direction", "admin", "seq_num", "msg_type", "msg_type_name", "raw"])
+        writer.writerow(["id", "ts", "direction", "admin", "seq_num", "msg_type", "msg_type_name", "user", "raw"])
         yield buf.getvalue()
         for e in entries:
             buf = io.StringIO()
@@ -130,6 +150,7 @@ def export_messages(
                 e.seq_num,
                 e.msg_type,
                 e.msg_type_name,
+                usernames.get(e.user_id, "") if e.user_id else "",
                 e.raw.replace("\x01", "|"),
             ])
             yield buf.getvalue()

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/api/routers/sessions.py

@@ -240,7 +240,8 @@ async def stop_session(
 
 
 @router.post("/{session_id}/send")
-async def send_message(session_id: str, body: SendMessageRequest, _cfg: OwnedSession, sm: SM):
+async def send_message(session_id: str, body: SendMessageRequest, _cfg: OwnedSession,
+                       sm: SM, user: CurrentUser):
     from ...core.fix_builder import build_message_from_raw
     from ...core.fix_time import utc_timestamp
 
@@ -252,7 +253,7 @@ async def send_message(session_id: str, body: SendMessageRequest, _cfg: OwnedSes
     except ValueError as e:
         raise HTTPException(status_code=422, detail=str(e))
 
-    ok = await sm.send_message(session_id, msg)
+    ok = await sm.send_message(session_id, msg, user_id=user.uid)
     if not ok:
         raise HTTPException(status_code=409, detail="Session not logged on")
     return {"ok": True}

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/api/schemas.py

@@ -162,6 +162,8 @@ class MessageEntryResponse(BaseModel):
     ts: str
     fields: dict[str, str]
     raw: str
+    user_id: Optional[str] = None    # uid of the sending user; None if unattributed
+    username: Optional[str] = None   # resolved display name for user_id
 
 
 class SendMessageRequest(BaseModel):

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/core/message_log.py

@@ -24,6 +24,7 @@ class LogEntry:
     msg_type_name: str      # human-readable, e.g. "NewOrderSingle"
     fields: dict = field(default_factory=dict)  # {tag_int: value_str}
     id: Optional[int] = None  # SQLite rowid; None for in-memory entries
+    user_id: Optional[str] = None  # uid of the sending user; None for inbound/engine sends
 
     def pretty(self, use_names: bool = True) -> str:
         """Multi-line human-readable display."""
@@ -58,11 +59,12 @@ class MessageLog:
     # Write
     # ------------------------------------------------------------------
 
-    def add(self, direction: str, admin: bool, raw: str) -> LogEntry:
+    def add(self, direction: str, admin: bool, raw: str, user_id: Optional[str] = None) -> LogEntry:
         """Parse and store a message. Returns the created LogEntry."""
-        return self.add_entry(direction, admin, raw, parse_raw(raw))
+        return self.add_entry(direction, admin, raw, parse_raw(raw), user_id=user_id)
 
-    def add_entry(self, direction: str, admin: bool, raw: str, fields: dict) -> LogEntry:
+    def add_entry(self, direction: str, admin: bool, raw: str, fields: dict,
+                  user_id: Optional[str] = None) -> LogEntry:
         """Store a LogEntry from pre-parsed fields (no re-parse). Returns it."""
         mt = get_msg_type(fields)
         entry = LogEntry(
@@ -74,6 +76,7 @@ class MessageLog:
             msg_type=mt,
             msg_type_name=msg_type_name(mt) if mt else "Unknown",
             fields=fields,
+            user_id=user_id,
         )
         with self._lock:
             if len(self._entries) >= self._max:

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/core/message_store.py

@@ -27,8 +27,14 @@ from .message_log import LogEntry
 
 logger = logging.getLogger(__name__)
 
+def _migrate_to_2(conn: sqlite3.Connection) -> None:
+    """v2: attribute each row to the user who sent it (NULL for inbound and
+    engine-originated sends). Existing rows backfill to NULL."""
+    conn.execute("ALTER TABLE messages ADD COLUMN user_id TEXT")
+
+
 # Schema migrations keyed by target version (>1). Empty = baseline v1 only.
-_MIGRATIONS: dict = {}
+_MIGRATIONS: dict = {2: _migrate_to_2}
 
 # Bound on the writer queue. Inserts past this are dropped (and counted) rather
 # than growing memory without limit under sustained overload. Generous enough
@@ -55,15 +61,22 @@ CREATE TABLE IF NOT EXISTS messages (
     fields_json   TEXT    NOT NULL
 )
 """
+# NOTE: user_id is intentionally NOT here — it's added by the v2 migration so
+# fresh and pre-existing DBs converge on the same path (CREATE TABLE stays at
+# the v1 baseline per the db_migrations contract).
 _CREATE_INDEX = """
 CREATE INDEX IF NOT EXISTS idx_msg_session ON messages(session_id, id DESC)
 """
 _INSERT = """
 INSERT INTO messages
-    (session_id, ts, direction, admin, seq_num, msg_type, msg_type_name, raw, fields_json)
-VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    (session_id, ts, direction, admin, seq_num, msg_type, msg_type_name, raw, fields_json, user_id)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 """
 
+# Column list shared by the row-reading SELECTs, kept in sync with _row_to_entry.
+_COLUMNS = ("id, session_id, ts, direction, admin, seq_num, "
+            "msg_type, msg_type_name, raw, fields_json, user_id")
+
 
 def _entry_to_row(session_id: str, entry: LogEntry) -> tuple:
     return (
@@ -76,6 +89,7 @@ def _entry_to_row(session_id: str, entry: LogEntry) -> tuple:
         entry.msg_type_name,
         entry.raw,
         json.dumps(entry.fields),
+        entry.user_id,
     )
 
 
@@ -86,7 +100,7 @@ def _like_escape(s: str) -> str:
 
 
 def _row_to_entry(row) -> LogEntry:
-    row_id, _, ts, direction, admin, seq_num, mt, mt_name, raw, fields_json = row
+    row_id, _, ts, direction, admin, seq_num, mt, mt_name, raw, fields_json, user_id = row
     return LogEntry(
         direction=direction,
         admin=bool(admin),
@@ -97,6 +111,7 @@ def _row_to_entry(row) -> LogEntry:
         msg_type_name=mt_name,
         fields=json.loads(fields_json),
         id=row_id,
+        user_id=user_id,
     )
 
 
@@ -294,11 +309,12 @@ class MessageStore:
     # Write
     # ------------------------------------------------------------------
 
-    def add(self, direction: str, admin: bool, raw: str) -> LogEntry:
+    def add(self, direction: str, admin: bool, raw: str, user_id: Optional[str] = None) -> LogEntry:
         """Parse message, enqueue DB write, return LogEntry immediately."""
-        return self.add_entry(direction, admin, raw, parse_raw(raw))
+        return self.add_entry(direction, admin, raw, parse_raw(raw), user_id=user_id)
 
-    def add_entry(self, direction: str, admin: bool, raw: str, fields: dict) -> LogEntry:
+    def add_entry(self, direction: str, admin: bool, raw: str, fields: dict,
+                  user_id: Optional[str] = None) -> LogEntry:
         """Build + enqueue a LogEntry from pre-parsed fields (no re-parse)."""
         mt = get_msg_type(fields)
         entry = LogEntry(
@@ -310,6 +326,7 @@ class MessageStore:
             msg_type=mt,
             msg_type_name=msg_type_name(mt) if mt else "Unknown",
             fields=fields,
+            user_id=user_id,
         )
         self._writer.enqueue(self._session_id, entry)
         return entry
@@ -354,10 +371,7 @@ class MessageStore:
             params.append(before_id)
 
         where_sql = " AND ".join(where)
-        select = (
-            "SELECT id, session_id, ts, direction, admin, seq_num, "
-            f"msg_type, msg_type_name, raw, fields_json FROM messages WHERE {where_sql}"
-        )
+        select = f"SELECT {_COLUMNS} FROM messages WHERE {where_sql}"
 
         if limit is not None:
             # Fetch last N qualifying rows in ascending order
@@ -392,11 +406,7 @@ class MessageStore:
             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 = ?"
-        )
+        select = f"SELECT {_COLUMNS} FROM messages WHERE session_id = ?"
         params: list = [self._session_id]
 
         with closing(_connect(self._db_path)) as conn:

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/core/session.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import logging
 import os
 import time
@@ -18,6 +19,16 @@ from .fix_application import FixApplication
 if TYPE_CHECKING:
     from .message_store import MessageWriter
 
+# The uid of the user driving the current send, or None for engine/auto sends.
+# Set in `send_message` before `await send_app`; read when fixcore's to_app/
+# to_admin callback logs the outbound message. A ContextVar (not an instance
+# attr) because fixcore invokes those callbacks synchronously within the same
+# asyncio task under its _send_lock — task-local storage keeps concurrent
+# senders on one session from cross-attributing.
+_sending_user: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "fixture_sending_user", default=None,
+)
+
 logger = logging.getLogger(__name__)
 
 
@@ -191,18 +202,26 @@ class Session:
             },
         ))
 
-    async def send_message(self, message: Message) -> bool:
-        """Send an application-level FIX message. Returns False if not logged on."""
+    async def send_message(self, message: Message, user_id: Optional[str] = None) -> bool:
+        """Send an application-level FIX message. Returns False if not logged on.
+
+        `user_id` attributes the send to a human user; it's stashed in a
+        ContextVar that the to_app/to_admin log path reads. None (engine/auto
+        sends) logs an unattributed message.
+        """
         if self._transport is None or self._fixcore_session_id is None:
             return False
         transport_session = self._transport.sessions.get(self._fixcore_session_id)
         if transport_session is None or not transport_session.is_logged_on:
             return False
+        token = _sending_user.set(user_id)
         try:
             await transport_session.send_app(message)
             return True
         except Exception:
             return False
+        finally:
+            _sending_user.reset(token)
 
     # ------------------------------------------------------------------
     # Sequence number management
@@ -271,15 +290,19 @@ class Session:
             admin = event.payload.get("admin", False)
             raw = event.payload.get("raw", "")
             fields = event.payload.get("fields")
+            # Attribute outbound sends to the user driving them (set in
+            # send_message); inbound and engine/auto sends stay unattributed.
+            user_id = _sending_user.get() if direction == "OUT" else None
             if fields is not None:
                 # Pre-parsed by FixApplication from the fixcore Message — no re-parse.
-                entry = self._message_log.add_entry(direction, admin, raw, fields)
+                entry = self._message_log.add_entry(direction, admin, raw, fields, user_id=user_id)
             else:
-                entry = self._message_log.add(direction, admin, raw)
+                entry = self._message_log.add(direction, admin, raw, user_id=user_id)
             event.payload["seq_num"] = entry.seq_num
             event.payload["msg_type"] = entry.msg_type
             event.payload["msg_type_name"] = entry.msg_type_name
             event.payload["fields"] = entry.fields
+            event.payload["user_id"] = entry.user_id
             if direction == "OUT":
                 self.state.last_sent_seq_num = entry.seq_num
             else:

{fixtureqa-0.12.1 → fixtureqa-0.14.0}/fixture/core/session_manager.py

@@ -170,8 +170,8 @@ class SessionManager:
     def set_seqnums(self, session_id: str, sender, target) -> tuple:
         return self._get(session_id).set_seqnums(sender, target)
 
-    async def send_message(self, session_id: str, message) -> bool:
-        return await self._get(session_id).send_message(message)
+    async def send_message(self, session_id: str, message, user_id: Optional[str] = None) -> bool:
+        return await self._get(session_id).send_message(message, user_id=user_id)
 
     # ------------------------------------------------------------------
     # Event subscription