fixtureqa 0.10.4__tar.gz → 0.12.0__tar.gz

{fixtureqa-0.10.4/fixtureqa.egg-info → fixtureqa-0.12.0}/PKG-INFO

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

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/api/routers/fix_spec.py

@@ -3,13 +3,17 @@ from typing import Annotated
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from ...core.fix_spec_parser import (
-    get_fields, get_message, get_messages, spec_ref_for_version,
+    GroupNode, get_fields, get_message, get_message_tree, get_messages,
+    spec_ref_for_version,
 )
 from ...core.spec_overlay_store import SpecOverlayStore
 from ...core.spec_store import SpecStore
 from ...core.user_store import User
 from ..deps import get_current_user, get_spec_overlay_store, get_spec_store
-from ..schemas import FieldRefResponse, MessageDefResponse, MessageSummaryResponse
+from ..schemas import (
+    FieldNodeResponse, FieldRefResponse, GroupNodeResponse, MessageDefResponse,
+    MessageSummaryResponse,
+)
 
 from fixcore.message import bundled_app_specs, bundled_begin_strings
 
@@ -140,3 +144,77 @@ def get_message_def(
         )
 
     raise HTTPException(status_code=404, detail=f"Message type '{msg_type}' not found in {begin_string}")
+
+
+def _node_to_response(node) -> FieldNodeResponse | GroupNodeResponse:
+    if isinstance(node, GroupNode):
+        return GroupNodeResponse(
+            tag=node.tag,
+            name=node.name,
+            required=node.required,
+            delimiter=node.delimiter,
+            children=[_node_to_response(c) for c in node.children],
+        )
+    return FieldNodeResponse(
+        tag=node.tag,
+        name=node.name,
+        type=node.type,
+        required=node.required,
+        values=node.values,
+    )
+
+
+@router.get("/messages/{msg_type}/tree",
+            response_model=list[FieldNodeResponse | GroupNodeResponse])
+def get_message_tree_def(
+    msg_type: str,
+    begin_string: str = Query("FIX.4.2"),
+    spec: str | None = Query(None),
+    overlay_store: SO = ...,
+    spec_store: SS = ...,
+    user: CurrentUser = ...,
+):
+    """Group-preserving field tree for one message type (spec viewer)."""
+    spec_ref = _resolve_spec_ref(begin_string, spec, user, spec_store)
+
+    tree = get_message_tree(spec_ref, msg_type)
+    if tree is not None:
+        return [_node_to_response(n) for n in tree]
+
+    # Custom overlay message types have no repeating groups — flat leaves only.
+    overlay = overlay_store.get_overlay(user.uid)
+    field_defs = get_fields(spec_ref)
+    for om in overlay.get("messages", []):
+        if om.get("msg_type") != msg_type:
+            continue
+        nodes: list[FieldNodeResponse | GroupNodeResponse] = []
+        for f in om.get("fields", []):
+            tag = f.get("tag", 0)
+            fd = field_defs.get(tag)
+            nodes.append(FieldNodeResponse(
+                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 nodes
+
+    raise HTTPException(status_code=404, detail=f"Message type '{msg_type}' not found in {begin_string}")
+
+
+@router.get("/fields", response_model=list[FieldRefResponse])
+def list_fields(
+    begin_string: str = Query("FIX.4.2"),
+    spec: str | None = Query(None),
+    spec_store: SS = ...,
+    user: CurrentUser = ...,
+):
+    """The full field catalogue for a spec, ordered by tag number."""
+    spec_ref = _resolve_spec_ref(begin_string, spec, user, spec_store)
+    field_defs = get_fields(spec_ref)
+    return [
+        FieldRefResponse(tag=fd.number, name=fd.name, type=fd.type,
+                         required=False, values=fd.values)
+        for _, fd in sorted(field_defs.items())
+    ]

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/api/schemas.py

@@ -309,6 +309,29 @@ class MessageDefResponse(BaseModel):
     fields: list[FieldRefResponse]
 
 
+# Group-preserving message tree (spec viewer). A node is a leaf field or a
+# repeating group whose ``children`` recurse.
+class FieldNodeResponse(BaseModel):
+    kind: str = "field"
+    tag: int
+    name: str
+    type: str
+    required: bool
+    values: dict[str, str]
+
+
+class GroupNodeResponse(BaseModel):
+    kind: str = "group"
+    tag: int                              # the NoXxx counter tag
+    name: str
+    required: bool
+    delimiter: int
+    children: list["FieldNodeResponse | GroupNodeResponse"]
+
+
+GroupNodeResponse.model_rebuild()
+
+
 # Templates
 
 # Scenarios

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/core/fix_spec_parser.py

@@ -60,6 +60,31 @@ class MessageDef:
     fields: list[FieldRef] = field(default_factory=list)
 
 
+@dataclass
+class FieldNode:
+    """A leaf field in a message tree."""
+    tag: int
+    name: str
+    type: str
+    required: bool
+    values: dict[str, str]
+
+
+@dataclass
+class GroupNode:
+    """A repeating group in a message tree; ``children`` preserves member order
+    and nests further ``GroupNode``s for nested groups."""
+    tag: int                        # the NoXxx counter tag
+    name: str
+    required: bool
+    delimiter: int                  # first tag inside each group instance
+    children: list["FieldNode | GroupNode"] = field(default_factory=list)
+
+
+# A node is either a leaf field or a repeating group.
+Node = "FieldNode | GroupNode"
+
+
 # ---------------------------------------------------------------------------
 # Internal cache (per spec ref). fixcore caches the parsed DataDictionary
 # itself; this caches the adapter's per-message FieldRef lists.
@@ -69,6 +94,7 @@ class MessageDef:
 class _Spec:
     field_defs: dict[int, FieldDef]
     messages: dict[str, MessageDef]
+    trees: dict[str, list]          # msg_type → list[FieldNode | GroupNode]
 
 
 _CACHE: dict[str, _Spec] = {}
@@ -117,6 +143,7 @@ def _build_spec(spec_ref: str) -> _Spec:
     }
 
     messages: dict[str, MessageDef] = {}
+    trees: dict[str, list] = {}
     for m in dd.messages():
         messages[m.msg_type] = MessageDef(
             msg_type=m.msg_type,
@@ -124,7 +151,8 @@ def _build_spec(spec_ref: str) -> _Spec:
             category="admin" if m.msg_cat == "admin" else "app",
             fields=_message_field_refs(m, field_defs),
         )
-    return _Spec(field_defs=field_defs, messages=messages)
+        trees[m.msg_type] = _message_tree(m, field_defs)
+    return _Spec(field_defs=field_defs, messages=messages, trees=trees)
 
 
 def _message_field_refs(msg, field_defs: dict[int, FieldDef]) -> list[FieldRef]:
@@ -168,13 +196,62 @@ def _message_field_refs(msg, field_defs: dict[int, FieldDef]) -> list[FieldRef]:
     return refs
 
 
+def _message_tree(msg, field_defs: dict[int, FieldDef]) -> list:
+    """Build a group-preserving tree for one message.
+
+    fixcore stores body fields as required/optional *sets* (no source order) and
+    has already inlined ``<component>`` refs, so the tree faithfully reproduces
+    repeating-group nesting only. Top-level leaves are ordered required-first
+    then by tag; group members keep fixcore's ordered ``members`` list. The NoXxx
+    counter tags are rendered as group nodes, never duplicated as leaves.
+    """
+    def leaf(tag: int, required: bool) -> FieldNode:
+        fd = field_defs.get(tag)
+        return FieldNode(
+            tag=tag,
+            name=fd.name if fd else f"Tag{tag}",
+            type=fd.type if fd else "STRING",
+            required=required,
+            values=fd.values if fd else {},
+        )
+
+    def group_node(gd: GroupDef, required: bool) -> GroupNode:
+        counter = field_defs.get(gd.number_tag)
+        children: list = []
+        for tag in gd.members:
+            nested = gd.nested_groups.get(tag)
+            if nested is not None:
+                children.append(group_node(nested, False))
+            else:
+                children.append(leaf(tag, False))
+        return GroupNode(
+            tag=gd.number_tag,
+            name=counter.name if counter else f"Tag{gd.number_tag}",
+            required=required,
+            delimiter=gd.delimiter,
+            children=children,
+        )
+
+    counters = set(msg.groups)
+    nodes: list = []
+    for tag in sorted(msg.required):
+        if tag not in counters:
+            nodes.append(leaf(tag, True))
+    for tag in sorted(msg.optional):
+        if tag not in counters:
+            nodes.append(leaf(tag, False))
+    for counter, gd in msg.groups.items():
+        nodes.append(group_node(gd, counter in msg.required))
+    return nodes
+
+
 def _get_spec(spec_ref: str) -> _Spec:
     if spec_ref not in _CACHE:
         try:
             _CACHE[spec_ref] = _build_spec(spec_ref)
         except Exception as e:
             logger.error("Failed to load FIX spec %s: %s", spec_ref, e)
-            _CACHE[spec_ref] = _Spec(field_defs={}, messages={})
+            _CACHE[spec_ref] = _Spec(field_defs={}, messages={}, trees={})
     return _CACHE[spec_ref]
 
 
@@ -195,6 +272,15 @@ def get_message(spec_ref: str, msg_type: str) -> MessageDef | None:
     return _get_spec(spec_ref).messages.get(msg_type)
 
 
+def get_message_tree(spec_ref: str, msg_type: str) -> list | None:
+    """The group-preserving field tree for one MsgType, or None if unknown.
+
+    Returns a list of ``FieldNode``/``GroupNode`` (nested). See
+    :func:`_message_tree` for the ordering/nesting semantics.
+    """
+    return _get_spec(spec_ref).trees.get(msg_type)
+
+
 def get_fields(spec_ref: str) -> dict[int, FieldDef]:
     """All field definitions keyed by tag number."""
     return _get_spec(spec_ref).field_defs

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/core/perf_engine.py

@@ -868,7 +868,7 @@ class PerfRun:
     def _exec(self, of: dict, **kw) -> Optional[Message]:
         """Build one ExecReport via the exec template when configured, else the
         built-in builder (Phase B). Both enforce the standard correlation tags."""
-        if self.config.payload.exec_template_id:
+        if self._factory.has_exec_template:
             return self._factory.build_exec_message(of, **kw)
         return self._build_exec(of, **kw)
 

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/core/perf_models.py

@@ -175,10 +175,14 @@ class PayloadConfig(BaseModel):
     fill: FillPayloadConfig = Field(default_factory=FillPayloadConfig)
     scenarios: list[ScenarioConfig] = Field(default_factory=list)
     # Phase B — optional TemplateStore template ids (resolved for the run's owner).
-    # order_template_id shapes single-order injection (ignored when scenarios are set);
-    # exec_template_id shapes the venue's ack/fill ExecReports. Omitted → built-in builders.
-    order_template_id: Optional[str] = None
-    exec_template_id: Optional[str] = None
+    # The *_ids lists shape single-order injection / the venue's ack-fill ExecReports;
+    # when more than one is given the engine round-robins them per order / per report.
+    # Empty → built-in builders. The singular *_id fields are the legacy one-template
+    # form kept for old saved configs; _fold_template_ids merges them into the lists.
+    order_template_ids: list[str] = Field(default_factory=list)
+    exec_template_ids: list[str] = Field(default_factory=list)
+    order_template_id: Optional[str] = None   # deprecated — folded into order_template_ids
+    exec_template_id: Optional[str] = None     # deprecated — folded into exec_template_ids
     # Send-options parity with the standard send UI (client-injected messages only):
     # auto_expiry rewrites ExpireTime(126)/ExpireDate(432) to a future instant when
     # the message already carries them (never inserts); gen_rules set tag → generator
@@ -194,6 +198,21 @@ class PayloadConfig(BaseModel):
             raise ValueError("scenario weights must be > 0")
         return self
 
+    @model_validator(mode="after")
+    def _fold_template_ids(self) -> "PayloadConfig":
+        # Old saved configs / API clients send the singular order_template_id /
+        # exec_template_id; fold those into the lists so the engine only reads
+        # the lists. Drop blanks and de-dup while preserving order.
+        if not self.order_template_ids and self.order_template_id:
+            self.order_template_ids = [self.order_template_id]
+        if not self.exec_template_ids and self.exec_template_id:
+            self.exec_template_ids = [self.exec_template_id]
+        self.order_template_ids = [t for t in dict.fromkeys(self.order_template_ids) if t]
+        self.exec_template_ids = [t for t in dict.fromkeys(self.exec_template_ids) if t]
+        self.order_template_id = self.order_template_ids[0] if self.order_template_ids else None
+        self.exec_template_id = self.exec_template_ids[0] if self.exec_template_ids else None
+        return self
+
 
 class RelayConfig(BaseModel):
     """middle_manager relay behaviour. Verbatim forward by default; an optional

{fixtureqa-0.10.4 → fixtureqa-0.12.0}/fixture/core/perf_payload.py

@@ -127,8 +127,12 @@ class PayloadFactory:
         self._sender = sender_comp_id
         self._target = target_comp_id
         self._templates: dict[str, dict[int, str]] = {}
-        self._order_tpl: Optional[dict[int, str]] = None   # Phase B single-order template
-        self._exec_tpl: Optional[dict[int, str]] = None    # Phase B ExecReport template
+        # Phase B standalone templates — one or more order / ExecReport specs,
+        # round-robined per order / per report when more than one is configured.
+        self._order_tpls: list[dict[int, str]] = []
+        self._exec_tpls: list[dict[int, str]] = []
+        self._order_tpl_i = 0
+        self._exec_tpl_i = 0
         self._gen_rules: dict[int, str] = {}               # tag → expression, every client msg
         self._counters: dict[int, int] = {}                # seq() state, per tag per run
         self._symbol_i = 0
@@ -157,9 +161,10 @@ class PayloadFactory:
 
         # Phase B standalone templates (no scenario sequence → no {ref:}).
         p = self.config.payload
-        self._order_tpl = self._load_standalone(p.order_template_id, _SIMPLE, "order",
-                                                merge_rules=True)
-        self._exec_tpl = self._load_standalone(p.exec_template_id, _SIMPLE | _EXEC_TOKENS, "exec")
+        self._order_tpls = [self._load_standalone(tid, _SIMPLE, "order", merge_rules=True)
+                            for tid in p.order_template_ids]
+        self._exec_tpls = [self._load_standalone(tid, _SIMPLE | _EXEC_TOKENS, "exec")
+                           for tid in p.exec_template_ids]
 
     def _parse_gen_rules(self, vars_: dict) -> dict[int, str]:
         rules: dict[int, str] = {}
@@ -238,6 +243,26 @@ class PayloadFactory:
             return
         raise PerfConfigError(f"unknown token {{{tok}}} in template {tpl_id!r}")
 
+    # -- standalone template selection (round-robin) -------------------
+
+    @property
+    def has_order_template(self) -> bool:
+        return bool(self._order_tpls)
+
+    @property
+    def has_exec_template(self) -> bool:
+        return bool(self._exec_tpls)
+
+    def _next_order_tpl(self) -> dict[int, str]:
+        tpl = self._order_tpls[self._order_tpl_i % len(self._order_tpls)]
+        self._order_tpl_i += 1
+        return tpl
+
+    def _next_exec_tpl(self) -> dict[int, str]:
+        tpl = self._exec_tpls[self._exec_tpl_i % len(self._exec_tpls)]
+        self._exec_tpl_i += 1
+        return tpl
+
     # -- order context (per scenario instance / per single order) ------
 
     def new_context(self) -> dict:
@@ -262,8 +287,8 @@ class PayloadFactory:
     def build_single_order(self) -> tuple[Message, dict]:
         ctx = self.new_context()
         corr, clordid = _uuid(), self._clordid()
-        if self._order_tpl is not None:
-            return self._build_order_from_template(ctx, corr, clordid)
+        if self._order_tpls:
+            return self._build_order_from_template(self._next_order_tpl(), ctx, corr, clordid)
         p = self.config.payload.order
         is_market = p.ord_type == "market"
         msg = Message()
@@ -437,11 +462,11 @@ class PayloadFactory:
 
     # -- Phase B: templated single order ------------------------------------
 
-    def _build_order_from_template(self, ctx: dict, corr: str, clordid: str) -> tuple[Message, dict]:
-        """Render the order template, then ensure the standard tags the venue and
+    def _build_order_from_template(self, fields: dict[int, str], ctx: dict,
+                                   corr: str, clordid: str) -> tuple[Message, dict]:
+        """Render one order template, then ensure the standard tags the venue and
         correlator need are present (injected from ctx when the template omits them),
         so an authored order spec can never break filling/correlation."""
-        fields = self._order_tpl
         mtype = fields.get(35, "D")
         msg = Message()
         msg.header.set(35, mtype)
@@ -501,7 +526,7 @@ class PayloadFactory:
         }
         msg = Message()
         msg.header.set(35, "8")
-        for tag, raw in self._exec_tpl.items():
+        for tag, raw in self._next_exec_tpl().items():
             if tag == 35:
                 continue
             msg.set_field(tag, self._resolve_exec(raw, of, exec_ctx, tag))