fixtureqa 0.11.0__tar.gz → 0.12.0__tar.gz

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

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

{fixtureqa-0.11.0 → 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.11.0 → 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.11.0 → 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