fixtureqa 0.15.0__tar.gz → 0.16.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.15.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.15.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.15.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")
@@ -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.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.16.0/fixture/core/atdl_parser.py

@@ -0,0 +1,359 @@
+"""
+ATDL (Algorithmic Trading Definition Language) parser — Phase 1 sketch.
+
+Parses a FIXatdl 1.1 file into a flat, UI-friendly model: the strategies it
+offers and, per strategy, the parameters (FIX tag + type + optionality + enum
+pairs) needed to build a ``NewOrderSingle``.
+
+Scope: strategies + parameters (Phase 1) plus the **validation / flow-control**
+rules (Phase 3): ``<StrategyEdit>`` (cross-field validation assertions) and
+``<StateRule>`` (conditional enable/hide of a control). Both hang off ``<Edit>``
+boolean-expression trees; named ``<Edit id=...>`` reused via ``<EditRef>`` are
+collected so the frontend evaluator can resolve them. ``<StrategyLayout>``
+itself is walked only to map a ``<Control parameterRef=...>`` to the parameter a
+``<StateRule>`` governs — the control widgets are not otherwise interpreted.
+
+Edit/StrategyEdit/StateRule semantics (FIXatdl 1.1 spec):
+  * ``Edit`` is a boolean expression: either an ``operator`` (EX/NX/EQ/NE/LE/LT/
+    GE/GT over ``field`` vs ``value`` or ``field2``) **or** a ``logicOperator``
+    (AND/OR/XOR/NOT over child Edits) — never both.
+  * ``StrategyEdit`` is an *assertion*: the order is valid when its Edit is TRUE,
+    and ``errorMessage`` is shown when it is FALSE.
+  * ``StateRule`` action is *in-effect when its Edit is TRUE*: ``enabled="false"``
+    disables the control, ``visible="false"`` hides it (etc.).
+The boolean evaluation itself lives in the frontend (``lib/atdlEval.ts``) since
+it runs live against form input; this module only produces the rule tree.
+
+Security: ATDL files are untrusted uploads, so parsing goes through
+``defusedxml`` (XXE / billion-laughs neutralised). This module has zero UI
+dependencies (core layer rule).
+
+Namespaces (FIXatdl 1.1)::
+
+    Core       http://www.fixprotocol.org/FIXatdl-1-1/Core
+    Layout     http://www.fixprotocol.org/FIXatdl-1-1/Layout
+    Validation http://www.fixprotocol.org/FIXatdl-1-1/Validation
+    xsi        http://www.w3.org/2001/XMLSchema-instance
+
+The parameter type is carried in the ``xsi:type`` attribute as a QName
+(``"t:Int_t"``). Phase 1 takes the *local part* only (``"Int_t"``) — every ATDL
+parameter type lives in the Core namespace, so prefix resolution buys nothing
+here; revisit if Layout parsing (multiple namespaces) is added.
+"""
+
+from __future__ import annotations
+
+# aliased: the Edit dataclass has a `field` attribute (ATDL's field name) which
+# would otherwise shadow dataclasses.field inside the class body.
+from dataclasses import dataclass, field as _dcfield
+
+# defusedxml exposes the stdlib ElementTree API but blocks entity/DTD attacks.
+from defusedxml.ElementTree import fromstring, ParseError
+
+CORE_NS = "http://www.fixprotocol.org/FIXatdl-1-1/Core"
+
+# Parameter xsi:type -> the FIXture field kind the form should render.
+# (Coarser than the full ATDL type list; enough to pick an input widget.)
+_TYPE_KIND = {
+    "Int_t": "int", "Float_t": "float", "Price_t": "float", "Qty_t": "float",
+    "Amt_t": "float", "PriceOffset_t": "float", "Percentage_t": "float",
+    "Boolean_t": "bool",
+    "Char_t": "char", "String_t": "string", "MultipleCharValue_t": "string",
+    "MultipleStringValue_t": "string", "Currency_t": "string",
+    "Country_t": "string", "Exchange_t": "string", "Tenor_t": "string",
+    "UTCTimestamp_t": "timestamp", "UTCTimeOnly_t": "time",
+    "LocalMktDate_t": "date", "MonthYear_t": "string",
+}
+
+
+class AtdlParseError(ValueError):
+    """Raised when the payload is not a parseable FIXatdl document."""
+
+
+@dataclass
+class EnumPair:
+    enum_id: str        # ATDL-internal id, referenced by controls/edits
+    wire_value: str     # what goes on the wire for this tag
+
+
+@dataclass
+class Parameter:
+    name: str
+    fix_tag: int                          # 0 if the file omitted fixTag
+    type: str                             # raw ATDL type, e.g. "Price_t"
+    kind: str                             # form kind: int|float|bool|string|…
+    required: bool
+    enums: list[EnumPair] = _dcfield(default_factory=list)
+
+
+@dataclass
+class Edit:
+    """A FIXatdl boolean-expression node.
+
+    Exactly one shape is populated: a *comparison/existence* leaf
+    (``operator`` + ``field`` + ``value``/``field2``), a *logical* node
+    (``logic`` + ``children``), or an *EditRef* leaf (``ref`` = a named Edit id).
+    """
+    operator: str = ""      # EX/NX/EQ/NE/LE/LT/GE/GT ('' unless a comparison)
+    field: str = ""         # parameter *name* being tested
+    field2: str = ""        # compare against another field's value
+    value: str = ""         # …or against this literal
+    has_value: bool = False # value="" (present) vs value absent
+    logic: str = ""         # AND/OR/XOR/NOT ('' unless a logical node)
+    ref: str = ""           # EditRef → id of a named Edit
+    id: str = ""            # this Edit's own id (if reusable)
+    children: list["Edit"] = _dcfield(default_factory=list)
+
+
+@dataclass
+class StrategyEdit:
+    error_message: str      # shown when the assertion (edit) is FALSE
+    edit: Edit
+
+
+@dataclass
+class StateRule:
+    param: str              # parameter name (from the containing Control)
+    enabled: str            # "true"/"false"/"" (unset) — applied when edit TRUE
+    visible: str            # "true"/"false"/"" (unset)
+    value: str              # value to set when edit TRUE ('' if unset)
+    edit: Edit
+
+
+@dataclass
+class Strategy:
+    name: str
+    ui_rep: str                           # display label (falls back to name)
+    wire_value: str                       # StrategyIdentifier value on the wire
+    fix_msg_type: str                     # usually "D"
+    parameters: list[Parameter] = _dcfield(default_factory=list)
+    edits: list[StrategyEdit] = _dcfield(default_factory=list)      # validation
+    state_rules: list[StateRule] = _dcfield(default_factory=list)   # enable/hide
+    named_edits: dict[str, Edit] = _dcfield(default_factory=dict)   # id → Edit (for EditRef)
+    has_layout: bool = False              # <StrategyLayout> present
+
+
+@dataclass
+class AtdlFile:
+    strategy_wire_tag: int                # tag carrying the strategy id (attr on <Strategies>)
+    strategies: list[Strategy] = _dcfield(default_factory=list)
+
+
+# --- helpers ---------------------------------------------------------------
+
+def _local(tag: str) -> str:
+    """Strip a ``{namespace}local`` or ``prefix:local`` down to ``local``."""
+    if "}" in tag:
+        tag = tag.rsplit("}", 1)[1]
+    if ":" in tag:
+        tag = tag.rsplit(":", 1)[1]
+    return tag
+
+
+def _xsi_type(el) -> str:
+    """Local part of the element's ``xsi:type`` (``"t:Int_t"`` -> ``"Int_t"``)."""
+    for k, v in el.attrib.items():
+        if _local(k) == "type":
+            return _local(v)
+    return ""
+
+
+def _int_attr(el, name: str, default: int = 0) -> int:
+    try:
+        return int(el.get(name, ""))
+    except (TypeError, ValueError):
+        return default
+
+
+def _find_local(parent, name: str):
+    """Yield direct children whose local tag == *name* (namespace-agnostic)."""
+    for child in parent:
+        if _local(child.tag) == name:
+            yield child
+
+
+# --- parsing ---------------------------------------------------------------
+
+def parse_atdl(xml_text: str) -> AtdlFile:
+    """Parse a FIXatdl 1.1 document. Raises :class:`AtdlParseError` on failure."""
+    try:
+        root = fromstring(xml_text)
+    except (ParseError, ValueError) as e:
+        raise AtdlParseError(f"Not parseable XML: {e}") from e
+
+    if _local(root.tag) != "Strategies":
+        raise AtdlParseError(
+            f"Root element is <{_local(root.tag)}>, expected <Strategies>"
+        )
+
+    # Tag that carries the strategy identifier on the wire. ATDL puts it on
+    # <Strategies strategyIdentifierTag="…">; default to StrategyName (tag 848?)
+    # — leave 0 and let the caller decide when absent.
+    strategy_tag = _int_attr(root, "strategyIdentifierTag", 0)
+
+    strategies = [_parse_strategy(s) for s in _find_local(root, "Strategy")]
+    if not strategies:
+        raise AtdlParseError("Document defines no <Strategy> elements")
+    return AtdlFile(strategy_wire_tag=strategy_tag, strategies=strategies)
+
+
+def _parse_strategy(el) -> Strategy:
+    name = el.get("name", "")
+    strat = Strategy(
+        name=name,
+        ui_rep=el.get("uiRep") or name,
+        wire_value=el.get("wireValue", ""),
+        fix_msg_type=el.get("fixMsgType", "D"),
+    )
+    for child in el:
+        local = _local(child.tag)
+        if local == "Parameter":
+            strat.parameters.append(_parse_parameter(child))
+        elif local == "StrategyLayout":
+            strat.has_layout = True
+
+    # Validation assertions: <StrategyEdit> anywhere under the strategy (some
+    # files wrap them in a <StrategyEdits>/<Edits> container).
+    for se in _iter_local(el, "StrategyEdit"):
+        edit = _first_edit_child(se)
+        if edit is not None:
+            strat.edits.append(
+                StrategyEdit(error_message=se.get("errorMessage", ""), edit=edit))
+
+    # Flow control: a <StateRule> is nested in a <Control parameterRef=...>.
+    for ctrl in _iter_local(el, "Control"):
+        param_ref = ctrl.get("parameterRef", "")
+        for sr in _find_local(ctrl, "StateRule"):
+            edit = _first_edit_child(sr)
+            if edit is not None:
+                strat.state_rules.append(StateRule(
+                    param=param_ref,
+                    enabled=sr.get("enabled", ""),
+                    visible=sr.get("visible", ""),
+                    value=sr.get("value", ""),
+                    edit=edit,
+                ))
+
+    # Named edits (<Edit id=...> anywhere) → resolvable by <EditRef id=...>.
+    _collect_named_edits(el, strat.named_edits)
+    return strat
+
+
+def _iter_local(parent, name: str):
+    """Yield *all descendants* (any depth) whose local tag == *name*."""
+    for el in parent.iter():
+        if el is not parent and _local(el.tag) == name:
+            yield el
+
+
+def _first_edit_child(el):
+    """The <Edit> (or <EditRef>) directly under a StrategyEdit/StateRule."""
+    for child in el:
+        local = _local(child.tag)
+        if local in ("Edit", "EditRef"):
+            return _parse_edit(child)
+    return None
+
+
+def _parse_edit(el) -> Edit:
+    local = _local(el.tag)
+    if local == "EditRef":
+        return Edit(ref=el.get("id", ""))
+    e = Edit(
+        operator=el.get("operator", ""),
+        field=el.get("field", ""),
+        field2=el.get("field2", ""),
+        value=el.get("value", ""),
+        has_value="value" in el.attrib,
+        logic=el.get("logicOperator", ""),
+        id=el.get("id", ""),
+    )
+    for child in el:
+        if _local(child.tag) in ("Edit", "EditRef"):
+            e.children.append(_parse_edit(child))
+    return e
+
+
+def _collect_named_edits(el, out: dict) -> None:
+    """Map every ``id`` → parsed Edit for EditRef resolution on the frontend."""
+    for e in _iter_local(el, "Edit"):
+        eid = e.get("id", "")
+        if eid and eid not in out:
+            out[eid] = _parse_edit(e)
+
+
+# --- linting ---------------------------------------------------------------
+
+def _iter_edit_nodes(edit: Edit):
+    """Yield an Edit and all its descendant Edit nodes (refs not resolved)."""
+    yield edit
+    for child in edit.children:
+        yield from _iter_edit_nodes(child)
+
+
+def _edit_roots(s: Strategy):
+    """Every Edit tree in a strategy: validation, state rules, and named edits."""
+    for se in s.edits:
+        yield se.edit
+    for sr in s.state_rules:
+        yield sr.edit
+    yield from s.named_edits.values()
+
+
+def atdl_warnings(atdl: AtdlFile) -> list[str]:
+    """Non-fatal lint findings for an otherwise-parseable ATDL file.
+
+    These don't stop the file being used, but flag things that would make an
+    order incomplete or a rule inert — useful when authoring/validating a file.
+    """
+    w: list[str] = []
+    if not atdl.strategy_wire_tag:
+        w.append("No strategyIdentifierTag on <Strategies> — the strategy "
+                 "identifier won't be emitted on the order.")
+    for s in atdl.strategies:
+        if not s.parameters:
+            w.append(f"Strategy '{s.name}' declares no parameters.")
+        if not s.wire_value:
+            w.append(f"Strategy '{s.name}' has no wireValue.")
+        names = {p.name for p in s.parameters}
+        for p in s.parameters:
+            if not p.fix_tag:
+                w.append(f"Parameter '{p.name}' in '{s.name}' has no fixTag — "
+                         "it can't be sent.")
+        refs, fields = set(), set()
+        for root in _edit_roots(s):
+            for node in _iter_edit_nodes(root):
+                if node.ref:
+                    refs.add(node.ref)
+                if node.field:
+                    fields.add(node.field)
+                if node.field2:
+                    fields.add(node.field2)
+        for ref in sorted(refs):
+            if ref not in s.named_edits:
+                w.append(f"EditRef '{ref}' in '{s.name}' does not resolve to a "
+                         "named <Edit id=...>.")
+        for fld in sorted(fields):
+            if fld not in names:
+                w.append(f"An Edit in '{s.name}' references unknown field '{fld}'.")
+        for sr in s.state_rules:
+            if sr.param and sr.param not in names:
+                w.append(f"A StateRule in '{s.name}' targets unknown parameter "
+                         f"'{sr.param}'.")
+    return w
+
+
+def _parse_parameter(el) -> Parameter:
+    atdl_type = _xsi_type(el)
+    return Parameter(
+        name=el.get("name", ""),
+        fix_tag=_int_attr(el, "fixTag", 0),
+        type=atdl_type,
+        kind=_TYPE_KIND.get(atdl_type, "string"),
+        # ATDL `use` is "optional"/"required"; absent → optional.
+        required=(el.get("use", "optional").lower() == "required"),
+        enums=[
+            EnumPair(enum_id=ep.get("enumID", ""), wire_value=ep.get("wireValue", ""))
+            for ep in _find_local(el, "EnumPair")
+        ],
+    )