fixtureqa 0.15.0__tar.gz → 0.16.1__tar.gz

{fixtureqa-0.15.0/fixtureqa.egg-info → fixtureqa-0.16.1}/PKG-INFO

@@ -1,16 +1,17 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.15.0
+Version: 0.16.1
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.11.0
+Requires-Dist: fixcore-engine==0.11.1
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0
 Requires-Dist: python-jose[cryptography]>=3.3.0
 Requires-Dist: passlib[bcrypt]>=1.7.4
 Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: matplotlib>=3.7
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"

{fixtureqa-0.15.0 → fixtureqa-0.16.1}/README.md

@@ -1,6 +1,6 @@
 # FIXture
 
-A Python FIX protocol testing tool. Supports FIX 4.2 and 4.4, dynamic session creation at runtime (no restart required), and both initiator and acceptor roles per session.
+A Python FIX protocol testing tool. Supports FIX 4.0–4.4 and FIX 5.0 (over FIXT.1.1), dynamic session creation at runtime (no restart required), and both initiator and acceptor roles per session.
 
 ![FIXture](frontend/src/assets/logo-dark.svg)
 
@@ -8,16 +8,19 @@ A Python FIX protocol testing tool. Supports FIX 4.2 and 4.4, dynamic session cr
 
 ## Features
 
-- **FIX 4.2 and 4.4** support with bundled data dictionaries
-- **Initiator and acceptor** roles, configurable per session
+- **FIX 4.0–4.4 and FIX 5.0** — every classic version plus FIX 5.0/SP1/SP2 over FIXT.1.1 (transport + application dictionary, ApplVerID on the Logon), with bundled data dictionaries
+- **Custom data dictionaries** — upload per-user spec XMLs and pick them per session; built-in spec browser for every bundled/uploaded dictionary (messages, fields, enums, repeating groups)
+- **Initiator and acceptor** roles, configurable per session, with the full engine config surface (schedules, timers, resend/validation behaviour) in the session form
 - **Dynamic sessions** — add or remove sessions without restarting
-- **Multi-user auth** — JWT login, per-user session isolation, admin panel
-- **Message log** — real-time IN/OUT stream with field breakdown, filtering, cursor pagination
-- **Compose & send** — paste raw FIX or use message templates; auto-inject tag 60 and primary ID
+- **Multi-user auth** — JWT login and admin panel; sessions are visible and sendable to every user, control (start/stop/edit/delete) stays with the owner or an admin, and each sent message is attributed to the user who sent it
+- **Message log** — real-time IN/OUT stream with field breakdown, filtering, cursor pagination, and full-history search (substring or regex)
+- **Compose & send** — paste raw FIX or use message templates; one message per line sends a batch in order; auto-inject tag 60 and primary ID; value generators (`uuid()`, `ORD-{seq(8)}`, …)
+- **Algo orders (FIXatdl)** — upload a broker's ATDL file and build orders from a generated form: typed parameters, conditional enable/hide and cross-field validation (StateRules/StrategyEdits), the strategy identifier stamped automatically; validate-without-saving for authoring your own files
 - **Templates** — create/edit reusable message templates with FIX spec field definitions
+- **Custom tags** — per-user tag definitions (name, type, enum labels) that decode in the message log; ATDL parameters can register themselves automatically
 - **Scenarios** — automated send/expect/delay test scripts with live pass/fail results; repeatable steps/scenarios, value generators (`uuid()`, `ORD-{seq(8)}`, …) in send values, `{recv:<tag>}` to echo an order's tags into the ack/fill that answers it, and cross-session **suites** that coordinate through real FIX traffic (e.g. a client scenario and a venue scenario run together)
 - **Venue simulation** — auto-ack and auto-fill responses for inbound NewOrderSingles
-- **Performance testing** — rate-controlled order injection with latency correlation (p50/p95/p99), live dashboard, run history and CSV export; order/exec shapes templatable per counterparty; amend (35=G) and cancel (35=F) flavours with their own reply latencies (see [PERF.md](PERF.md))
+- **Performance testing** — rate-controlled order injection with latency correlation (p50/p95/p99), live dashboard, run history and CSV export; order/exec shapes templatable per counterparty; amend (35=G) and cancel (35=F) flavours with their own reply latencies; a 4-session relay topology (`client → relay → venue`) that measures per-hop pass-through latency (see [PERF.md](PERF.md))
 - **Log analysis** — Overview stats, Throughput chart, Reject detail, Latency measurement (p50/p95/p99)
 - **Export** — download session messages as CSV or raw FIX
 - **Sequence numbers** — view and reset TX/RX seqnums per session

{fixtureqa-0.15.0 → fixtureqa-0.16.1}/fixture/api/app.py

@@ -13,13 +13,14 @@ from ..core.scenario_store import ScenarioStore, ScenarioGroupStore
 from ..core.scenario_runner import ScenarioRunner
 from ..core.spec_overlay_store import SpecOverlayStore
 from ..core.spec_store import SpecStore
+from ..core.atdl_store import AtdlStore
 from ..core.template_store import TemplateStore
 from ..core.user_store import UserStore
 from .connection_manager import ConnectionManager
 from ..core.perf_engine import RunRegistry
 from ..core.perf_writer import PerfWriter
 from ..core.perf_store import PerfStore
-from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding, custom_tags, spec_overlay, specs, perf
+from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding, custom_tags, spec_overlay, specs, atdl, perf
 
 
 @asynccontextmanager
@@ -53,10 +54,10 @@ async def lifespan(app: FastAPI):
         await app.state.perf_registry.shutdown()
     except Exception:
         pass
-    # Force-stop all running sessions so their asyncio tasks can be cancelled cleanly
+    # Stop all running sessions so their asyncio tasks can be cancelled cleanly
     for sid in list(sm._sessions.keys()):
         try:
-            await sm.stop_session(sid, force=True)
+            await sm.stop_session(sid)
         except Exception:
             pass
     sm.close()  # flush SQLite writer
@@ -96,6 +97,7 @@ def create_app(
     app.state.custom_tag_store = CustomTagStore(data_dir)
     app.state.spec_overlay_store = SpecOverlayStore(data_dir)
     app.state.spec_store = SpecStore(data_dir)
+    app.state.atdl_store = AtdlStore(data_dir)
     perf_writer = PerfWriter(os.path.join(data_dir, "perf.db"))
     app.state.perf_writer = perf_writer
     app.state.perf_registry = RunRegistry(
@@ -122,6 +124,7 @@ def create_app(
     app.include_router(custom_tags.router, prefix="/api/custom-tags")
     app.include_router(spec_overlay.router, prefix="/api/spec-overlay")
     app.include_router(specs.router, prefix="/api/specs")
+    app.include_router(atdl.router, prefix="/api/atdl")
     app.include_router(perf.router, prefix="/api/perf")
     app.include_router(ws.router)
 

{fixtureqa-0.15.0 → fixtureqa-0.16.1}/fixture/api/deps.py

@@ -13,6 +13,7 @@ from ..core.scenario_runner import ScenarioRunner
 from ..core.custom_tag_store import CustomTagStore
 from ..core.spec_overlay_store import SpecOverlayStore
 from ..core.spec_store import SpecStore
+from ..core.atdl_store import AtdlStore
 from .connection_manager import ConnectionManager
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
@@ -127,6 +128,10 @@ def get_spec_store(request: HTTPConnection) -> SpecStore:
     return request.app.state.spec_store
 
 
+def get_atdl_store(request: HTTPConnection) -> AtdlStore:
+    return request.app.state.atdl_store
+
+
 def get_perf_registry(request: HTTPConnection):
     return request.app.state.perf_registry
 

fixtureqa-0.16.1/fixture/api/routers/atdl.py

@@ -0,0 +1,150 @@
+"""ATDL (Algorithmic Trading Definition Language) upload/list/delete + browse.
+
+A user uploads a broker's FIXatdl XML; this router persists it per-user and
+exposes the parsed strategies/parameters so the compose UI can render an algo
+order-entry form. Mirrors the custom-spec router (:mod:`.specs`).
+"""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Response, UploadFile, status
+
+from ...core.atdl_parser import AtdlParseError, atdl_warnings, parse_atdl
+from ...core.atdl_store import AtdlStore, AtdlValidationError
+from ...core.user_store import User
+from ..deps import get_atdl_store, get_current_user
+
+router = APIRouter(tags=["atdl"])
+
+AS = Annotated[AtdlStore, Depends(get_atdl_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+# ATDL files are XML text; a large broker suite is well under 2 MB.
+_MAX_ATDL_BYTES = 2 * 1024 * 1024
+
+
+def _edit_dict(e) -> dict:
+    """Serialise an Edit expression tree (see core.atdl_parser.Edit)."""
+    return {
+        "operator": e.operator,
+        "field": e.field,
+        "field2": e.field2,
+        "value": e.value,
+        "has_value": e.has_value,
+        "logic": e.logic,
+        "ref": e.ref,
+        "id": e.id,
+        "children": [_edit_dict(c) for c in e.children],
+    }
+
+
+def _strategy_dict(s) -> dict:
+    return {
+        "name": s.name,
+        "ui_rep": s.ui_rep,
+        "wire_value": s.wire_value,
+        "fix_msg_type": s.fix_msg_type,
+        "has_layout": s.has_layout,
+        # Retained for the UI's "advanced features" hint; now derived from the
+        # rules we actually parse (Phase 3) rather than mere presence.
+        "has_edits": bool(s.edits or s.state_rules),
+        "parameters": [
+            {
+                "name": p.name,
+                "fix_tag": p.fix_tag,
+                "type": p.type,
+                "kind": p.kind,
+                "required": p.required,
+                "true_wire_value": p.true_wire_value,
+                "false_wire_value": p.false_wire_value,
+                "enums": [{"enum_id": e.enum_id, "wire_value": e.wire_value}
+                          for e in p.enums],
+            }
+            for p in s.parameters
+        ],
+        "edits": [{"error_message": se.error_message, "edit": _edit_dict(se.edit)}
+                  for se in s.edits],
+        "state_rules": [
+            {"param": sr.param, "enabled": sr.enabled, "visible": sr.visible,
+             "value": sr.value, "edit": _edit_dict(sr.edit)}
+            for sr in s.state_rules
+        ],
+        "named_edits": {k: _edit_dict(v) for k, v in s.named_edits.items()},
+    }
+
+
+@router.get("")
+def list_atdl(store: AS, user: CurrentUser) -> list[dict]:
+    """This user's uploaded ATDL files (name + strategy count)."""
+    return store.list(user.uid)
+
+
+@router.post("", status_code=status.HTTP_201_CREATED)
+async def upload_atdl(file: UploadFile, store: AS, user: CurrentUser) -> dict:
+    raw = await file.read()
+    if len(raw) > _MAX_ATDL_BYTES:
+        raise HTTPException(status_code=413, detail="ATDL file too large")
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        raise HTTPException(status_code=400, detail="ATDL must be UTF-8 XML")
+    try:
+        return store.save(user.uid, file.filename or "algos.xml", text)
+    except AtdlValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/validate", status_code=status.HTTP_200_OK)
+async def validate_atdl(file: UploadFile, user: CurrentUser) -> dict:
+    """Parse + lint an ATDL file **without saving it** (library/authoring check).
+
+    Returns ``valid: true`` with the parsed strategies and any non-fatal
+    ``warnings`` on success, or ``valid: false`` with the parse ``error`` (HTTP
+    200 either way — a parse failure is a validation result, not a request error).
+    """
+    raw = await file.read()
+    if len(raw) > _MAX_ATDL_BYTES:
+        raise HTTPException(status_code=413, detail="ATDL file too large")
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return {"valid": False, "error": "ATDL must be UTF-8 XML"}
+    try:
+        parsed = parse_atdl(text)
+    except AtdlParseError as e:
+        return {"valid": False, "error": str(e)}
+    return {
+        "valid": True,
+        "name": file.filename or "",
+        "strategy_wire_tag": parsed.strategy_wire_tag,
+        "strategy_count": len(parsed.strategies),
+        "warnings": atdl_warnings(parsed),
+        "strategies": [_strategy_dict(s) for s in parsed.strategies],
+    }
+
+
+@router.get("/{name}")
+def get_atdl(name: str, store: AS, user: CurrentUser) -> dict:
+    """Parsed strategies/parameters (+ lint warnings) for one uploaded ATDL file."""
+    try:
+        parsed = store.get_parsed(user.uid, name)
+    except AtdlValidationError as e:
+        # Missing file or a file that no longer parses.
+        raise HTTPException(status_code=404, detail=str(e))
+    return {
+        "name": name,
+        "strategy_wire_tag": parsed.strategy_wire_tag,
+        "warnings": atdl_warnings(parsed),
+        "strategies": [_strategy_dict(s) for s in parsed.strategies],
+    }
+
+
+@router.delete("/{name}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_atdl(name: str, store: AS, user: CurrentUser) -> Response:
+    try:
+        deleted = store.delete(user.uid, name)
+    except AtdlValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    if not deleted:
+        raise HTTPException(status_code=404, detail="ATDL file not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

{fixtureqa-0.15.0 → fixtureqa-0.16.1}/fixture/api/routers/sessions.py

@@ -1,5 +1,5 @@
 from typing import Annotated, Optional
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException
 
 from ...core.message_store import MessageStore
 from ...core.session_manager import SessionManager
@@ -56,6 +56,8 @@ def _config_from_request(body: SessionConfigRequest, owner_uid: str) -> SessionC
 
 def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStore] = None,
                       counts: Optional[dict] = None) -> SessionResponse:
+    """Sessions are visible to all users, so every response carries
+    owner_username (resolved via `us`) for the UI owner badge / "Mine" filter."""
     cfg = sm.get_config(session_id)
     if cfg is None:
         raise HTTPException(status_code=404, detail="Session not found")
@@ -126,19 +128,11 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
     )
 
 
-def _owner_store(us: UserStore, user: User) -> Optional[UserStore]:
-    """Every response carries owner_username: sessions are visible to all users,
-    so the UI owner badge / "Mine" filter needs the owner on every session,
-    not just for admins."""
-    return us
-
-
 @router.get("/", response_model=list[SessionResponse])
 def list_sessions(sm: SM, us: US, user: CurrentUser):
     configs = sm.list_sessions_for_user(user.uid, is_admin=user.is_admin)
-    user_store = _owner_store(us, user)
     counts = sm.message_counts()
-    return [_session_response(sm, cfg.session_id, user_store, counts) for cfg in configs]
+    return [_session_response(sm, cfg.session_id, us, counts) for cfg in configs]
 
 
 @router.post("/", response_model=SessionResponse, status_code=201)
@@ -168,7 +162,7 @@ async def create_session(body: SessionConfigRequest, sm: SM, us: US, ss: SS, use
                 pass  # best-effort rollback; surface the original start failure
             raise HTTPException(status_code=500, detail=f"Failed to start session: {e}")
 
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/import", response_model=list[SessionResponse], status_code=201)
@@ -188,13 +182,13 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, us
             session_id = sm.add_session(cfg)
         except (HTTPException, ValueError, KeyError):
             continue  # invalid / conflicting entry — skip just this one
-        created.append(_session_response(sm, session_id, _owner_store(us, user)))
+        created.append(_session_response(sm, session_id, us))
     return created
 
 
 @router.get("/{session_id}", response_model=SessionResponse)
 def get_session(session_id: str, _cfg: ViewableSession, sm: SM, us: US, user: CurrentUser):
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.patch("/{session_id}", response_model=SessionResponse)
@@ -209,7 +203,7 @@ def update_session(session_id: str, body: UpdateSessionRequest, _cfg: OwnedSessi
         raise HTTPException(status_code=409, detail=str(e))
     except (ValueError, KeyError) as e:
         raise HTTPException(status_code=422, detail=str(e))
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.delete("/{session_id}", status_code=204)
@@ -226,20 +220,13 @@ async def start_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, use
         await sm.start_session(session_id)
     except RuntimeError as e:
         raise HTTPException(status_code=409, detail=str(e))
-    return _session_response(sm, session_id, _owner_store(us, user))
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/{session_id}/stop", response_model=SessionResponse)
-async def stop_session(
-    session_id: str,
-    _cfg: OwnedSession,
-    sm: SM,
-    us: US,
-    user: CurrentUser,
-    force: bool = Query(default=False),
-):
-    await sm.stop_session(session_id, force=force)
-    return _session_response(sm, session_id, _owner_store(us, user))
+async def stop_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: CurrentUser):
+    await sm.stop_session(session_id)
+    return _session_response(sm, session_id, us)
 
 
 @router.post("/{session_id}/send")
@@ -258,7 +245,13 @@ async def send_message(session_id: str, body: SendMessageRequest, _cfg: Viewable
     except ValueError as e:
         raise HTTPException(status_code=422, detail=str(e))
 
-    ok = await sm.send_message(session_id, msg, user_id=user.uid)
+    from ...core.session_manager import SendError
+    try:
+        ok = await sm.send_message(session_id, msg, user_id=user.uid)
+    except SendError as e:
+        # A real send failure on a logged-on session — report the engine's
+        # error instead of the misleading "not logged on".
+        raise HTTPException(status_code=500, detail=f"Send failed: {e}")
     if not ok:
         raise HTTPException(status_code=409, detail="Session not logged on")
     return {"ok": True}