fixtureqa 0.14.0__tar.gz → 0.16.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.14.0
+Version: 0.16.0
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
@@ -11,6 +11,7 @@ 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.14.0 → fixtureqa-0.16.0}/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
@@ -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.14.0 → fixtureqa-0.16.0}/fixture/api/connection_manager.py

@@ -263,11 +263,12 @@ class ConnectionManager:
         self._prune([ws for ws, ok in zip(targets, oks) if not ok])
 
     async def _broadcast(self, session_id: str, payload: dict, owner_uid: str) -> None:
-        # A connection receives the event if it is an admin, or its uid
-        # matches the session owner.
-        targets = [ws for ws, info in {**self._clients.get(session_id, {}),
-                                       **self._clients.get("*", {})}.items()
-                   if info.is_admin or info.uid == owner_uid]
+        # FIX sessions are visible to every user, so session events (status +
+        # message frames) go to all connections subscribed to this session's
+        # room or the global "*" room. `owner_uid` is retained for the call
+        # signature but no longer filters delivery.
+        targets = list({**self._clients.get(session_id, {}),
+                        **self._clients.get("*", {})}.keys())
         await self._fan_out(targets, payload)
 
     async def _broadcast_to_user(self, uid: str, data: dict) -> None:

{fixtureqa-0.14.0 → fixtureqa-0.16.0}/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")
@@ -66,8 +67,10 @@ def get_owned_session(
     user: User = Depends(get_current_user),
 ):
     """Resolve the `session_id` path param to its SessionConfig, enforcing
-    that the caller owns it (or is admin). One dependency instead of a
-    _check_ownership copy in every session-scoped router."""
+    that the caller owns it (or is admin). Use this for CONTROL actions
+    (start/stop, edit, delete, clear, seqnums). Viewing and sending are open to
+    every user via get_viewable_session — sessions are visible (and sendable) to
+    all."""
     sm: SessionManager = request.app.state.session_manager
     cfg = sm.get_config(session_id)
     if cfg is None:
@@ -77,6 +80,22 @@ def get_owned_session(
     return cfg
 
 
+def get_viewable_session(
+    session_id: str,
+    request: HTTPConnection,
+    _user: User = Depends(get_current_user),
+):
+    """Resolve the `session_id` path param to its SessionConfig for READ access.
+    Every authenticated user may view any session (FIX sessions are globally
+    visible); the only gate is that the session exists. Control actions still go
+    through get_owned_session for owner/admin enforcement."""
+    sm: SessionManager = request.app.state.session_manager
+    cfg = sm.get_config(session_id)
+    if cfg is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return cfg
+
+
 def get_housekeeping(request: HTTPConnection) -> HousekeepingService:
     return request.app.state.housekeeping
 
@@ -109,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.0/fixture/api/routers/atdl.py

@@ -0,0 +1,148 @@
+"""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,
+                "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.14.0 → fixtureqa-0.16.0}/fixture/api/routers/messages.py

@@ -9,13 +9,14 @@ from ...core.models import SessionConfig
 from ...core.session_manager import SessionManager
 from ...core.user_store import User, UserStore
 from ..schemas import MessageEntryResponse
-from ..deps import get_session_manager, get_owned_session, get_user_store
+from ..deps import get_session_manager, get_owned_session, get_viewable_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)]
+ViewableSession = Annotated[SessionConfig, Depends(get_viewable_session)]
 
 
 def _username_map(entries, users: UserStore) -> dict[str, str]:
@@ -48,7 +49,7 @@ def _to_response(e, usernames: dict[str, str]) -> MessageEntryResponse:
 @router.get("/{session_id}/messages", response_model=list[MessageEntryResponse])
 def get_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     direction: Optional[str] = Query(default=None, description="IN or OUT"),
@@ -81,7 +82,7 @@ def get_messages(
 @router.get("/{session_id}/messages/search", response_model=list[MessageEntryResponse])
 def search_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     q: str = Query(..., min_length=1, description="substring or regex query over raw FIX"),
@@ -106,7 +107,7 @@ def search_messages(
 @router.get("/{session_id}/messages/export")
 def export_messages(
     session_id: str,
-    _cfg: OwnedSession,
+    _cfg: ViewableSession,
     sm: SM,
     users: US,
     fmt: str = Query(default="csv", description="Export format: csv or fix"),

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

@@ -7,7 +7,7 @@ from ...core.models import SessionConfig, ConnectionType, SessionRole
 from ...core.user_store import User, UserStore
 from ...core.spec_store import SpecStore
 from ..schemas import SessionConfigRequest, SessionResponse, UpdateSessionRequest, SendMessageRequest, SeqNumRequest, SeqNumResponse
-from ..deps import get_session_manager, get_current_user, get_owned_session, get_user_store, get_spec_store
+from ..deps import get_session_manager, get_current_user, get_owned_session, get_viewable_session, get_user_store, get_spec_store
 
 router = APIRouter(tags=["sessions"])
 
@@ -16,6 +16,7 @@ US = Annotated[UserStore, Depends(get_user_store)]
 SS = Annotated[SpecStore, Depends(get_spec_store)]
 CurrentUser = Annotated[User, Depends(get_current_user)]
 OwnedSession = Annotated[SessionConfig, Depends(get_owned_session)]
+ViewableSession = Annotated[SessionConfig, Depends(get_viewable_session)]
 
 def _bundled_specs() -> set[str]:
     """Bundled spec names fixcore resolves by itself — transport dictionaries
@@ -126,8 +127,10 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
 
 
 def _owner_store(us: UserStore, user: User) -> Optional[UserStore]:
-    """Only admin responses carry owner_username (the UI owner badge / Mine filter)."""
-    return us if user.is_admin else None
+    """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])
@@ -190,7 +193,7 @@ def import_sessions(body: list[SessionConfigRequest], sm: SM, us: US, ss: SS, us
 
 
 @router.get("/{session_id}", response_model=SessionResponse)
-def get_session(session_id: str, _cfg: OwnedSession, sm: SM, us: US, user: CurrentUser):
+def get_session(session_id: str, _cfg: ViewableSession, sm: SM, us: US, user: CurrentUser):
     return _session_response(sm, session_id, _owner_store(us, user))
 
 
@@ -240,8 +243,10 @@ async def stop_session(
 
 
 @router.post("/{session_id}/send")
-async def send_message(session_id: str, body: SendMessageRequest, _cfg: OwnedSession,
+async def send_message(session_id: str, body: SendMessageRequest, _cfg: ViewableSession,
                        sm: SM, user: CurrentUser):
+    # Sending is open to any user who can view the session (not just the owner);
+    # each message is still attributed to the actual sender via user_id below.
     from ...core.fix_builder import build_message_from_raw
     from ...core.fix_time import utc_timestamp
 

{fixtureqa-0.14.0 → fixtureqa-0.16.0}/fixture/api/routers/ws.py

@@ -136,11 +136,12 @@ async def ws_single_session(
         await websocket.close(code=4003, reason="Unauthorized")
         return
 
-    # Check ownership of this specific session
+    # Sessions are visible to every authenticated user (read-only stream);
+    # the only requirement is that the session exists.
     cfg = sm.get_config(session_id)
-    if cfg is None or (not is_admin and cfg.owner_uid != uid):
-        logger.warning("WS /ws/%s: access denied for uid=%s", session_id, uid)
-        await websocket.close(code=4003, reason="Access denied")
+    if cfg is None:
+        logger.warning("WS /ws/%s: unknown session for uid=%s", session_id, uid)
+        await websocket.close(code=4004, reason="Session not found")
         return
 
     logger.info("WS /ws/%s: client connected uid=%s is_admin=%s", session_id, uid, is_admin)