fixtureqa 0.9.2__tar.gz → 0.9.4__tar.gz

{fixtureqa-0.9.2/fixtureqa.egg-info → fixtureqa-0.9.4}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.9.2
+Version: 0.9.4
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.9.1
+Requires-Dist: fixcore-engine==0.9.2
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0

fixtureqa-0.9.4/fixture/core/fix_builder.py

@@ -0,0 +1,69 @@
+"""
+Group-aware construction of outbound FIX messages from a raw string.
+
+The naive path — parse_raw() into a {tag: value} dict, then set_field() per tag —
+collapses repeating groups: duplicate member tags (e.g. three NoAllocs rows) all
+overwrite down to the last value, while the NoXxx count survives as a literal. So
+the wire ends up claiming N instances but carrying only one.
+
+This builder instead keeps fields in order and hands them to fixcore's
+``Message.from_fields`` (the lenient, fields-based counterpart to ``decode``),
+which splits repeating groups using each group's spec definition when a
+DataDictionary is supplied — the same code path the engine uses to decode
+inbound messages, so the two can't drift. Header / seqnum / checksum tags are
+dropped here; the session stamps them on send.
+
+Without a DataDictionary (or for a count tag the spec doesn't define) it falls
+back to flat fields — no worse than before, but standard groups now round-trip.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from fixcore.message import DataDictionary, Message
+
+SOH = "\x01"
+
+# Tags the transport owns; never copied from the user's raw into the body.
+CONTROL_TAGS = frozenset({8, 9, 10, 34, 49, 52, 56})
+_MSG_TYPE = 35
+_TRANSACT_TIME = 60
+
+
+def _ordered_pairs(raw: str) -> list[tuple[int, str]]:
+    """Parse raw FIX into an ORDERED list of (tag, value), preserving duplicates."""
+    norm = raw if SOH in raw else raw.replace("|", SOH)
+    pairs: list[tuple[int, str]] = []
+    for part in norm.split(SOH):
+        if "=" not in part:
+            continue
+        tag_str, _, value = part.partition("=")
+        try:
+            pairs.append((int(tag_str), value))
+        except ValueError:
+            continue
+    return pairs
+
+
+def build_message_from_raw(
+    raw: str,
+    data_dictionary: Optional[DataDictionary] = None,
+    *,
+    transact_time: Optional[str] = None,
+) -> Message:
+    """Build a fixcore Message from raw FIX, preserving repeating-group structure
+    when *data_dictionary* is supplied. Injects TransactTime(60) when
+    *transact_time* is given and absent. Raises ValueError if MsgType is missing."""
+    pairs = _ordered_pairs(raw)
+    msg_idx = next((i for i, (t, _) in enumerate(pairs) if t == _MSG_TYPE), None)
+    if msg_idx is None:
+        raise ValueError("Missing MsgType (tag 35)")
+
+    # Drop transport-owned tags; MsgType (35) stays — from_fields routes it to
+    # the header. The session stamps the control tags on send.
+    fields = [(t, v) for t, v in pairs if t not in CONTROL_TAGS]
+    if transact_time is not None and not any(t == _TRANSACT_TIME for t, _ in fields):
+        idx = next(i for i, (t, _) in enumerate(fields) if t == _MSG_TYPE)
+        fields.insert(idx + 1, (_TRANSACT_TIME, transact_time))
+
+    return Message.from_fields(fields, data_dictionary)