fixtureqa 0.1.5__tar.gz → 0.1.7__tar.gz

{fixtureqa-0.1.5/fixtureqa.egg-info → fixtureqa-0.1.7}/PKG-INFO

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

{fixtureqa-0.1.5 → fixtureqa-0.1.7}/fixture/api/app.py

@@ -5,14 +5,16 @@ from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 
+from ..core.custom_tag_store import CustomTagStore
 from ..core.housekeeping import HousekeepingService
 from ..core.session_manager import SessionManager
 from ..core.scenario_store import ScenarioStore
 from ..core.scenario_runner import ScenarioRunner
+from ..core.spec_overlay_store import SpecOverlayStore
 from ..core.template_store import TemplateStore
 from ..core.user_store import UserStore
 from .connection_manager import ConnectionManager
-from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding
+from .routers import sessions, messages, ws, auth, setup, admin, fix_spec, templates, scenarios, branding, custom_tags, spec_overlay
 
 
 @asynccontextmanager
@@ -56,6 +58,8 @@ def create_app(
     app.state.housekeeping = HousekeepingService(msg_db_path, log_dir, user_store)
     app.state.template_store = TemplateStore(data_dir)
     app.state.scenario_store = ScenarioStore(data_dir)
+    app.state.custom_tag_store = CustomTagStore(data_dir)
+    app.state.spec_overlay_store = SpecOverlayStore(data_dir)
     conn_manager: ConnectionManager = app.state.connection_manager
     app.state.scenario_runner = ScenarioRunner(
         session_manager, app.state.template_store, conn_manager.broadcast_scenario_event
@@ -71,6 +75,8 @@ def create_app(
     app.include_router(templates.router, prefix="/api/templates")
     app.include_router(scenarios.router, prefix="/api/scenarios")
     app.include_router(branding.router, prefix="/api")
+    app.include_router(custom_tags.router, prefix="/api/custom-tags")
+    app.include_router(spec_overlay.router, prefix="/api/spec-overlay")
     app.include_router(ws.router)
 
     # Serve built React app from fixture/static/

{fixtureqa-0.1.5 → fixtureqa-0.1.7}/fixture/api/deps.py

@@ -10,6 +10,8 @@ from ..core.housekeeping import HousekeepingService
 from ..core.template_store import TemplateStore
 from ..core.scenario_store import ScenarioStore
 from ..core.scenario_runner import ScenarioRunner
+from ..core.custom_tag_store import CustomTagStore
+from ..core.spec_overlay_store import SpecOverlayStore
 from .connection_manager import ConnectionManager
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
@@ -71,3 +73,11 @@ def get_scenario_store(request: HTTPConnection) -> ScenarioStore:
 
 def get_scenario_runner(request: HTTPConnection) -> ScenarioRunner:
     return request.app.state.scenario_runner
+
+
+def get_custom_tag_store(request: HTTPConnection) -> CustomTagStore:
+    return request.app.state.custom_tag_store
+
+
+def get_spec_overlay_store(request: HTTPConnection) -> SpecOverlayStore:
+    return request.app.state.spec_overlay_store

fixtureqa-0.1.7/fixture/api/routers/custom_tags.py

@@ -0,0 +1,41 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from ...core.custom_tag_store import CustomTagStore
+from ...core.user_store import User
+from ..deps import get_current_user, get_custom_tag_store
+
+router = APIRouter(tags=["custom-tags"])
+
+CT = Annotated[CustomTagStore, Depends(get_custom_tag_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+FIELD_TYPES = ["STRING", "CHAR", "INT", "PRICE", "QTY", "BOOLEAN", "UTCTIMESTAMP", "NUMINGROUP", "FLOAT", "SEQNUM"]
+
+
+class CustomTagRequest(BaseModel):
+    number: int
+    name: str
+    type: str = "STRING"
+    values: dict[str, str] = {}
+
+
+@router.get("")
+def list_custom_tags(store: CT, user: CurrentUser) -> list[dict]:
+    return store.list_tags(user.uid)
+
+
+@router.post("")
+def upsert_custom_tag(body: CustomTagRequest, store: CT, user: CurrentUser) -> dict:
+    if body.number < 1:
+        raise HTTPException(status_code=422, detail="Tag number must be >= 1")
+    return store.upsert_tag(user.uid, body.number, body.name, body.type, body.values)
+
+
+@router.delete("/{number}")
+def delete_custom_tag(number: int, store: CT, user: CurrentUser) -> dict:
+    if not store.delete_tag(user.uid, number):
+        raise HTTPException(status_code=404, detail="Tag not found")
+    return {"ok": True}

fixtureqa-0.1.7/fixture/api/routers/fix_spec.py

@@ -0,0 +1,96 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from ...core.fix_spec_parser import get_fields, get_message, get_messages
+from ...core.spec_overlay_store import SpecOverlayStore
+from ...core.user_store import User
+from ..deps import get_current_user, get_spec_overlay_store
+from ..schemas import FieldRefResponse, MessageDefResponse, MessageSummaryResponse
+
+router = APIRouter(tags=["fix-spec"])
+
+SUPPORTED = {"FIX.4.2", "FIX.4.4"}
+
+SO = Annotated[SpecOverlayStore, Depends(get_spec_overlay_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+def _validate_begin_string(begin_string: str) -> None:
+    if begin_string not in SUPPORTED:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported begin_string '{begin_string}'. Use: {sorted(SUPPORTED)}",
+        )
+
+
+@router.get("/messages", response_model=list[MessageSummaryResponse])
+def list_messages(
+    begin_string: str = Query("FIX.4.2"),
+    overlay_store: SO = ...,
+    user: CurrentUser = ...,
+):
+    _validate_begin_string(begin_string)
+    spec = [MessageSummaryResponse(msg_type=m.msg_type, name=m.name, category=m.category)
+            for m in get_messages(begin_string)]
+    spec_types = {m.msg_type for m in spec}
+
+    overlay = overlay_store.get_overlay(user.uid)
+    extra = [
+        MessageSummaryResponse(
+            msg_type=om["msg_type"],
+            name=om["name"],
+            category=om.get("category", "app"),
+        )
+        for om in overlay.get("messages", [])
+        if om.get("msg_type") and om["msg_type"] not in spec_types
+    ]
+    return spec + extra
+
+
+@router.get("/messages/{msg_type}", response_model=MessageDefResponse)
+def get_message_def(
+    msg_type: str,
+    begin_string: str = Query("FIX.4.2"),
+    overlay_store: SO = ...,
+    user: CurrentUser = ...,
+):
+    _validate_begin_string(begin_string)
+
+    msg = get_message(begin_string, msg_type)
+    if msg is not None:
+        return MessageDefResponse(
+            msg_type=msg.msg_type,
+            name=msg.name,
+            category=msg.category,
+            fields=[
+                FieldRefResponse(tag=f.tag, name=f.name, type=f.type, required=f.required, values=f.values)
+                for f in msg.fields
+            ],
+        )
+
+    # Check user's spec overlay for custom message types
+    overlay = overlay_store.get_overlay(user.uid)
+    field_defs = get_fields(begin_string)
+    for om in overlay.get("messages", []):
+        if om.get("msg_type") != msg_type:
+            continue
+        fields = []
+        for f in om.get("fields", []):
+            tag = f.get("tag", 0)
+            fd = field_defs.get(tag)
+            fields.append(FieldRefResponse(
+                tag=tag,
+                name=fd.name if fd else f"Tag{tag}",
+                type=fd.type if fd else "STRING",
+                required=f.get("required", False),
+                values=fd.values if fd else {},
+            ))
+        return MessageDefResponse(
+            msg_type=msg_type,
+            name=om["name"],
+            category=om.get("category", "app"),
+            fields=fields,
+        )
+
+    raise HTTPException(status_code=404, detail=f"Message type '{msg_type}' not found in {begin_string}")

fixtureqa-0.1.7/fixture/api/routers/spec_overlay.py

@@ -0,0 +1,39 @@
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from ...core.spec_overlay_store import SpecOverlayStore
+from ...core.user_store import User
+from ..deps import get_current_user, get_spec_overlay_store
+
+router = APIRouter(tags=["spec-overlay"])
+
+SO = Annotated[SpecOverlayStore, Depends(get_spec_overlay_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+class OverlayField(BaseModel):
+    tag: int
+    required: bool = False
+
+
+class OverlayMessage(BaseModel):
+    msg_type: str
+    name: str
+    category: str = "app"
+    fields: list[OverlayField] = []
+
+
+class SpecOverlayRequest(BaseModel):
+    messages: list[OverlayMessage] = []
+
+
+@router.get("")
+def get_overlay(store: SO, user: CurrentUser) -> dict:
+    return store.get_overlay(user.uid)
+
+
+@router.put("")
+def set_overlay(body: SpecOverlayRequest, store: SO, user: CurrentUser) -> dict:
+    return store.set_overlay(user.uid, body.model_dump())

fixtureqa-0.1.7/fixture/core/custom_tag_store.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import json
+import os
+from threading import Lock
+
+
+class CustomTagStore:
+    def __init__(self, data_dir: str) -> None:
+        self._data_dir = data_dir
+        self._lock = Lock()
+
+    def _path(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "custom_tags.json")
+
+    def _load(self, uid: str) -> dict[int, dict]:
+        try:
+            with open(self._path(uid)) as f:
+                return {int(k): v for k, v in json.load(f).items()}
+        except (FileNotFoundError, json.JSONDecodeError, ValueError):
+            return {}
+
+    def _save(self, uid: str, tags: dict[int, dict]) -> None:
+        path = self._path(uid)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump({str(k): v for k, v in tags.items()}, f, indent=2)
+        os.replace(tmp, path)
+
+    def list_tags(self, uid: str) -> list[dict]:
+        with self._lock:
+            tags = self._load(uid)
+            return sorted(
+                [{"number": n, **v} for n, v in tags.items()],
+                key=lambda x: x["number"],
+            )
+
+    def upsert_tag(self, uid: str, number: int, name: str, type_: str, values: dict[str, str]) -> dict:
+        with self._lock:
+            tags = self._load(uid)
+            tags[number] = {"name": name, "type": type_, "values": values}
+            self._save(uid, tags)
+            return {"number": number, "name": name, "type": type_, "values": values}
+
+    def delete_tag(self, uid: str, number: int) -> bool:
+        with self._lock:
+            tags = self._load(uid)
+            if number not in tags:
+                return False
+            del tags[number]
+            self._save(uid, tags)
+            return True

fixtureqa-0.1.7/fixture/core/spec_overlay_store.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import json
+import os
+from threading import Lock
+
+_EMPTY: dict = {"messages": []}
+
+
+class SpecOverlayStore:
+    def __init__(self, data_dir: str) -> None:
+        self._data_dir = data_dir
+        self._lock = Lock()
+
+    def _path(self, uid: str) -> str:
+        return os.path.join(self._data_dir, uid, "spec_overlay.json")
+
+    def get_overlay(self, uid: str) -> dict:
+        try:
+            with open(self._path(uid)) as f:
+                return json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return dict(_EMPTY)
+
+    def set_overlay(self, uid: str, overlay: dict) -> dict:
+        path = self._path(uid)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp = path + ".tmp"
+        with self._lock:
+            with open(tmp, "w") as f:
+                json.dump(overlay, f, indent=2)
+            os.replace(tmp, path)
+        return overlay