fixcore-engine 0.1.0__py3-none-any.whl

fixcore/message/data_dictionary.py

@@ -0,0 +1,298 @@
+"""DataDictionary — loads a QuickFIX XML spec and validates FIX messages."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from fixcore.message.exceptions import InvalidMessage
+
+# Imported here to avoid circular import at module level; also used as constants
+TAG_BODY_LENGTH = 9
+TAG_CHECKSUM = 10
+
+
+# ---------------------------------------------------------------------------
+# Data model
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class FieldDef:
+    """Definition of a single FIX field."""
+    number: int
+    name: str
+    type: str                              # STRING, INT, PRICE, QTY, CHAR, …
+    values: dict[str, str] = field(default_factory=dict)  # enum → description
+
+
+@dataclass
+class GroupDef:
+    """Definition of a repeating group."""
+    number_tag: int                        # NoXxx counter tag (e.g. 78 NoAllocs)
+    delimiter: int                         # first expected tag inside each instance
+    members: list[int]                     # ordered member tags
+    nested_groups: dict[int, "GroupDef"] = field(default_factory=dict)
+
+
+@dataclass
+class MessageDef:
+    """Definition of a FIX message type."""
+    name: str
+    msg_type: str                          # e.g. "D", "0", "A"
+    msg_cat: str                           # "admin" | "app"
+    required: set[int] = field(default_factory=set)
+    optional: set[int] = field(default_factory=set)
+    groups: dict[int, GroupDef] = field(default_factory=dict)
+
+    @property
+    def all_fields(self) -> set[int]:
+        return self.required | self.optional
+
+
+# ---------------------------------------------------------------------------
+# DataDictionary
+# ---------------------------------------------------------------------------
+
+class DataDictionary:
+    """Parses a QuickFIX-format XML spec and validates Message objects.
+
+    Usage::
+
+        dd = DataDictionary.from_xml("specs/FIX42.xml")
+        dd.validate(message)          # raises InvalidMessage on failure
+    """
+
+    def __init__(self) -> None:
+        self._version: str = ""
+        self._fields_by_number: dict[int, FieldDef] = {}
+        self._fields_by_name: dict[str, int] = {}          # name → tag number
+        self._messages: dict[str, MessageDef] = {}         # msg_type → MessageDef
+        self._header: dict[int, bool] = {}                 # tag → required
+        self._trailer: dict[int, bool] = {}
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_xml(cls, path: str | Path) -> "DataDictionary":
+        """Load a DataDictionary from a QuickFIX XML spec file."""
+        tree = ET.parse(str(path))
+        root = tree.getroot()
+        dd = cls()
+        dd._version = _build_version(root)
+        dd._load_fields(root)
+        dd._load_header(root)
+        dd._load_trailer(root)
+        dd._load_messages(root)
+        return dd
+
+    @classmethod
+    def from_string(cls, xml_text: str) -> "DataDictionary":
+        """Load a DataDictionary from an XML string (useful in tests)."""
+        root = ET.fromstring(xml_text)
+        dd = cls()
+        dd._version = _build_version(root)
+        dd._load_fields(root)
+        dd._load_header(root)
+        dd._load_trailer(root)
+        dd._load_messages(root)
+        return dd
+
+    # ------------------------------------------------------------------
+    # Internal loaders
+    # ------------------------------------------------------------------
+
+    def _load_fields(self, root: ET.Element) -> None:
+        fields_el = root.find("fields")
+        if fields_el is None:
+            return
+        for f in fields_el.findall("field"):
+            number = int(f.get("number", 0))
+            name = f.get("name", "")
+            ftype = f.get("type", "STRING").upper()
+            values = {
+                v.get("enum", ""): v.get("description", "")
+                for v in f.findall("value")
+            }
+            fd = FieldDef(number=number, name=name, type=ftype, values=values)
+            self._fields_by_number[number] = fd
+            self._fields_by_name[name] = number
+
+    def _load_header(self, root: ET.Element) -> None:
+        header_el = root.find("header")
+        if header_el is None:
+            return
+        for f in header_el.findall("field"):
+            tag = self._resolve_tag(f.get("name", ""))
+            if tag is not None:
+                self._header[tag] = f.get("required", "N").upper() == "Y"
+
+    def _load_trailer(self, root: ET.Element) -> None:
+        trailer_el = root.find("trailer")
+        if trailer_el is None:
+            return
+        for f in trailer_el.findall("field"):
+            tag = self._resolve_tag(f.get("name", ""))
+            if tag is not None:
+                self._trailer[tag] = f.get("required", "N").upper() == "Y"
+
+    def _load_messages(self, root: ET.Element) -> None:
+        messages_el = root.find("messages")
+        if messages_el is None:
+            return
+        for msg_el in messages_el.findall("message"):
+            msg_type = msg_el.get("msgtype", "")
+            name = msg_el.get("name", "")
+            cat = msg_el.get("msgcat", "app").lower()
+            msg_def = MessageDef(name=name, msg_type=msg_type, msg_cat=cat)
+            self._parse_fields_and_groups(msg_el, msg_def.required, msg_def.optional, msg_def.groups)
+            self._messages[msg_type] = msg_def
+
+    def _parse_fields_and_groups(
+        self,
+        parent: ET.Element,
+        required: set[int],
+        optional: set[int],
+        groups: dict[int, GroupDef],
+    ) -> None:
+        for child in parent:
+            if child.tag == "field":
+                tag = self._resolve_tag(child.get("name", ""))
+                if tag is None:
+                    continue
+                if child.get("required", "N").upper() == "Y":
+                    required.add(tag)
+                else:
+                    optional.add(tag)
+            elif child.tag == "group":
+                tag = self._resolve_tag(child.get("name", ""))
+                if tag is None:
+                    continue
+                req = child.get("required", "N").upper() == "Y"
+                if req:
+                    required.add(tag)
+                else:
+                    optional.add(tag)
+                group_def = self._parse_group(tag, child)
+                groups[tag] = group_def
+
+    def _parse_group(self, number_tag: int, group_el: ET.Element) -> GroupDef:
+        members: list[int] = []
+        nested: dict[int, GroupDef] = {}
+        delimiter: int = 0
+        for child in group_el:
+            if child.tag == "field":
+                tag = self._resolve_tag(child.get("name", ""))
+                if tag is not None:
+                    if delimiter == 0:
+                        delimiter = tag
+                    members.append(tag)
+            elif child.tag == "group":
+                tag = self._resolve_tag(child.get("name", ""))
+                if tag is not None:
+                    if delimiter == 0:
+                        delimiter = tag
+                    members.append(tag)
+                    nested[tag] = self._parse_group(tag, child)
+        return GroupDef(number_tag=number_tag, delimiter=delimiter, members=members, nested_groups=nested)
+
+    def _resolve_tag(self, name: str) -> int | None:
+        return self._fields_by_name.get(name)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    @property
+    def version(self) -> str:
+        return self._version
+
+    def field_def(self, tag: int) -> FieldDef:
+        """Return FieldDef for *tag*; raises KeyError if unknown."""
+        return self._fields_by_number[tag]
+
+    def field_tag(self, name: str) -> int:
+        """Return the tag number for field *name*; raises KeyError if unknown."""
+        return self._fields_by_name[name]
+
+    def message_def(self, msg_type: str) -> MessageDef:
+        """Return MessageDef for *msg_type*; raises KeyError if unknown."""
+        return self._messages[msg_type]
+
+    def is_header_field(self, tag: int) -> bool:
+        return tag in self._header
+
+    def is_trailer_field(self, tag: int) -> bool:
+        return tag in self._trailer
+
+    def validate(self, message: "Message") -> None:  # type: ignore[name-defined]
+        """Validate *message* against this DataDictionary.
+
+        Checks:
+        - MsgType is known
+        - All required header fields are present
+        - All required body fields are present
+        - All required trailer fields are present
+
+        Raises :exc:`InvalidMessage` on the first violation found.
+        """
+        from fixcore.message.message import Message  # local to avoid circular
+
+        msg_type = message.msg_type
+        if not msg_type:
+            raise InvalidMessage("Missing MsgType (tag 35)")
+
+        msg_def = self._messages.get(msg_type)
+        if msg_def is None:
+            raise InvalidMessage(f"Unknown MsgType: {msg_type!r}")
+
+        # BodyLength and CheckSum are computed by the engine on encode — skip them
+        COMPUTED_TAGS = {TAG_BODY_LENGTH, TAG_CHECKSUM}
+
+        # Required header fields
+        for tag, required in self._header.items():
+            if tag in COMPUTED_TAGS:
+                continue
+            if required and not message.header.has(tag):
+                name = self._fields_by_number.get(tag, FieldDef(tag, str(tag), "STRING")).name
+                raise InvalidMessage(f"Missing required header field: {name} ({tag})")
+
+        # Required body fields
+        for tag in msg_def.required:
+            if not message.has_field(tag):
+                name = self._fields_by_number.get(tag, FieldDef(tag, str(tag), "STRING")).name
+                raise InvalidMessage(
+                    f"Missing required field: {name} ({tag}) in {msg_def.name}"
+                )
+
+        # Required trailer fields
+        for tag, required in self._trailer.items():
+            if tag in COMPUTED_TAGS:
+                continue
+            if required and not message.trailer.has(tag):
+                name = self._fields_by_number.get(tag, FieldDef(tag, str(tag), "STRING")).name
+                raise InvalidMessage(f"Missing required trailer field: {name} ({tag})")
+
+    def validate_field_value(self, tag: int, value: str) -> bool:
+        """Return True if *value* is a valid enum for *tag*, or if *tag* has no enum."""
+        fd = self._fields_by_number.get(tag)
+        if fd is None or not fd.values:
+            return True
+        return value in fd.values
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _build_version(root: ET.Element) -> str:
+    fix_type = root.get("type", "FIX")
+    major = root.get("major", "4")
+    minor = root.get("minor", "2")
+    sp = root.get("servicepack", "")
+    version = f"{fix_type}.{major}.{minor}"
+    if sp and sp != "0":
+        version += f"SP{sp}"
+    return version

fixcore/message/exceptions.py

@@ -0,0 +1,21 @@
+"""FIX message exceptions."""
+
+
+class InvalidMessage(Exception):
+    """Raised when a FIX message fails DataDictionary validation."""
+
+
+class UnsupportedVersion(Exception):
+    """Raised when a message's BeginString has no matching DataDictionary."""
+
+
+class FieldNotFound(KeyError):
+    """Raised when a required field is absent from a message."""
+
+
+class UnsupportedMessageType(Exception):
+    """Raised by MessageCracker.on_message when no handler is registered for a MsgType."""
+
+    def __init__(self, msg_type: str) -> None:
+        super().__init__(f"No handler for MsgType {msg_type!r}")
+        self.msg_type = msg_type

fixcore/message/field.py

@@ -0,0 +1,147 @@
+"""FIX field and field-map primitives."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Iterator
+
+
+class Field:
+    """A single tag=value pair."""
+
+    __slots__ = ("tag", "value")
+
+    def __init__(self, tag: int, value: str) -> None:
+        self.tag = tag
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"Field({self.tag}={self.value!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Field):
+            return NotImplemented
+        return self.tag == other.tag and self.value == other.value
+
+
+class FieldMap:
+    """Ordered collection of FIX fields (tag → value).
+
+    Preserves insertion order.  Repeated tags are allowed (e.g. repeating
+    groups) and stored in order of insertion.
+    """
+
+    def __init__(self) -> None:
+        # tag → list[str] to support repeating tags
+        self._fields: OrderedDict[int, list[str]] = OrderedDict()
+
+    # ------------------------------------------------------------------
+    # Mutation
+    # ------------------------------------------------------------------
+
+    def set_field(self, tag: int, value: str) -> None:
+        """Set *tag* to *value*, replacing any existing value(s)."""
+        self._fields[tag] = [value]
+
+    def append_field(self, tag: int, value: str) -> None:
+        """Append *value* for *tag* (used for repeating groups)."""
+        if tag in self._fields:
+            self._fields[tag].append(value)
+        else:
+            self._fields[tag] = [value]
+
+    def remove_field(self, tag: int) -> None:
+        self._fields.pop(tag, None)
+
+    # ------------------------------------------------------------------
+    # Access
+    # ------------------------------------------------------------------
+
+    def get_field(self, tag: int) -> str:
+        """Return the first value for *tag*; raises KeyError if absent."""
+        return self._fields[tag][0]
+
+    def get_field_or(self, tag: int, default: str = "") -> str:
+        vals = self._fields.get(tag)
+        return vals[0] if vals else default
+
+    def has_field(self, tag: int) -> bool:
+        return tag in self._fields
+
+    # ------------------------------------------------------------------
+    # Iteration
+    # ------------------------------------------------------------------
+
+    def __iter__(self) -> Iterator[Field]:
+        """Yield all fields in insertion order, expanding repeated tags."""
+        for tag, values in self._fields.items():
+            for value in values:
+                yield Field(tag, value)
+
+    def __len__(self) -> int:
+        return sum(len(v) for v in self._fields.values())
+
+    def __repr__(self) -> str:
+        pairs = ", ".join(f"{t}={v!r}" for t, vs in self._fields.items() for v in vs)
+        return f"{self.__class__.__name__}({pairs})"
+
+
+class Group:
+    """One repeating group instance.
+
+    Holds the member fields for a single row within a FIX repeating group
+    (e.g. one entry in ``NoMsgTypes`` or one leg in ``NoLegs``).
+
+    Usage::
+
+        g = Group()
+        g.set_field(372, "D")   # RefMsgType
+        g.set_field(385, "S")   # MsgDirection
+        msg.add_group(384, g)   # NoMsgTypes count tag
+
+    Nested groups are supported via :meth:`add_group` / :meth:`get_groups`.
+    """
+
+    def __init__(self) -> None:
+        self._fields: dict[int, str] = {}
+        # Insertion order for both simple fields and nested-group count tags
+        self._order: list[int] = []
+        self._groups: dict[int, list["Group"]] = {}
+
+    # ------------------------------------------------------------------
+    # Simple field access (mirrors Message body API)
+    # ------------------------------------------------------------------
+
+    def set_field(self, tag: int, value: str) -> None:
+        if tag not in self._fields:
+            self._order.append(tag)
+        self._fields[tag] = value
+
+    def get_field(self, tag: int) -> str:
+        """Return the value for *tag*; raises KeyError if absent."""
+        return self._fields[tag]
+
+    def get_field_or(self, tag: int, default: str = "") -> str:
+        return self._fields.get(tag, default)
+
+    def has_field(self, tag: int) -> bool:
+        return tag in self._fields
+
+    # ------------------------------------------------------------------
+    # Nested groups
+    # ------------------------------------------------------------------
+
+    def add_group(self, count_tag: int, instance: "Group") -> None:
+        """Append a nested group instance and update the count field."""
+        if count_tag not in self._groups:
+            self._order.append(count_tag)
+            self._groups[count_tag] = []
+        self._groups[count_tag].append(instance)
+        self._fields[count_tag] = str(len(self._groups[count_tag]))
+
+    def get_groups(self, count_tag: int) -> "list[Group]":
+        return self._groups.get(count_tag, [])
+
+    def __repr__(self) -> str:
+        pairs = ", ".join(f"{t}={v!r}" for t, v in self._fields.items())
+        return f"Group({pairs})"