fixcore-engine 0.2.1__tar.gz → 0.4.0__tar.gz

{fixcore_engine-0.2.1/fixcore_engine.egg-info → fixcore_engine-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixcore-engine
-Version: 0.2.1
+Version: 0.4.0
 Summary: Pure Python FIX protocol engine
 Author-email: Aidan Chisholm <aidan.chisholm@gmail.com>
 License: MIT License

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/log/file_log.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 
 from fixcore.log.base import Log, LogFactory
@@ -20,7 +20,7 @@ def _session_filename(session_id: SessionID) -> str:
 
 
 def _now() -> str:
-    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
+    return datetime.now(tz=UTC).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
 
 
 class FileLog(Log):

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/log/screen.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 
 import sys
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from fixcore.log.base import Log, LogFactory
 from fixcore.session.session_id import SessionID
 
 
 def _now() -> str:
-    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
+    return datetime.now(tz=UTC).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
 
 
 class ScreenLog(Log):

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/__init__.py

@@ -1,16 +1,25 @@
 """FIX message layer — encoding, decoding, and field definitions."""
 
 from fixcore.message.cracker import MessageCracker
-from fixcore.message.data_dictionary import DataDictionary, FieldDef, GroupDef, MessageDef
+from fixcore.message.data_dictionary import (
+    DataDictionary,
+    FieldDef,
+    GroupDef,
+    MessageDef,
+    load_data_dictionary,
+)
 from fixcore.message.exceptions import (
-    FieldNotFound, InvalidMessage, UnsupportedMessageType, UnsupportedVersion,
+    FieldNotFound,
+    InvalidMessage,
+    UnsupportedMessageType,
+    UnsupportedVersion,
 )
 from fixcore.message.field import Field, FieldMap, Group
 from fixcore.message.message import Header, Message, Trailer
 
 __all__ = [
     "MessageCracker",
-    "DataDictionary", "FieldDef", "GroupDef", "MessageDef",
+    "DataDictionary", "FieldDef", "GroupDef", "MessageDef", "load_data_dictionary",
     "FieldNotFound", "InvalidMessage", "UnsupportedMessageType", "UnsupportedVersion",
     "Field", "FieldMap", "Group",
     "Header", "Message", "Trailer",

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/cracker.py

@@ -25,11 +25,12 @@ level::
 
 from __future__ import annotations
 
+from collections.abc import Callable
+
 from fixcore.message.exceptions import UnsupportedMessageType
 from fixcore.message.message import Message
 from fixcore.session.session_id import SessionID
 
-
 # ---------------------------------------------------------------------------
 # MsgType → handler method name registry
 # ---------------------------------------------------------------------------
@@ -230,7 +231,9 @@ class MessageCracker:
 # already have an explicit implementation on the class.
 # ---------------------------------------------------------------------------
 
-def _make_default_handler(name: str):  # noqa: ANN202
+def _make_default_handler(
+    name: str,
+) -> Callable[[MessageCracker, Message, SessionID], None]:
     def handler(self: MessageCracker, message: Message, session_id: SessionID) -> None:
         self.on_message(message, session_id)
     handler.__name__ = name

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/data_dictionary.py

@@ -4,11 +4,22 @@ from __future__ import annotations
 
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass, field
+from functools import cache
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from fixcore.message.exceptions import InvalidMessage
 
+if TYPE_CHECKING:
+    from fixcore.message.message import Message
+
+# SessionRejectReason codes (FIX session-level)
+REJECT_REQUIRED_TAG_MISSING = 1
+REJECT_VALUE_OUT_OF_RANGE = 5
+REJECT_INVALID_MSGTYPE = 11
+
 # Imported here to avoid circular import at module level; also used as constants
+TAG_MSG_TYPE = 35
 TAG_BODY_LENGTH = 9
 TAG_CHECKSUM = 10
 
@@ -32,7 +43,7 @@ class GroupDef:
     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)
+    nested_groups: dict[int, GroupDef] = field(default_factory=dict)
 
 
 @dataclass
@@ -76,7 +87,7 @@ class DataDictionary:
     # ------------------------------------------------------------------
 
     @classmethod
-    def from_xml(cls, path: str | Path) -> "DataDictionary":
+    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()
@@ -89,7 +100,7 @@ class DataDictionary:
         return dd
 
     @classmethod
-    def from_string(cls, xml_text: str) -> "DataDictionary":
+    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()
@@ -147,7 +158,9 @@ class DataDictionary:
             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._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(
@@ -196,7 +209,9 @@ class DataDictionary:
                         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)
+        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)
@@ -227,7 +242,7 @@ class DataDictionary:
     def is_trailer_field(self, tag: int) -> bool:
         return tag in self._trailer
 
-    def validate(self, message: "Message") -> None:  # type: ignore[name-defined]
+    def validate(self, message: Message, *, check_field_values: bool = False) -> None:
         """Validate *message* against this DataDictionary.
 
         Checks:
@@ -235,18 +250,27 @@ class DataDictionary:
         - All required header fields are present
         - All required body fields are present
         - All required trailer fields are present
+        - If *check_field_values* is True, every enum-bearing header/body field
+          carries a value defined in the dictionary (out-of-range → Reject)
 
         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)")
+            raise InvalidMessage(
+                "Missing MsgType (tag 35)",
+                reason=REJECT_REQUIRED_TAG_MISSING,
+                ref_tag=35,
+            )
 
         msg_def = self._messages.get(msg_type)
         if msg_def is None:
-            raise InvalidMessage(f"Unknown MsgType: {msg_type!r}")
+            raise InvalidMessage(
+                f"Unknown MsgType: {msg_type!r}",
+                reason=REJECT_INVALID_MSGTYPE,
+                ref_tag=35,
+            )
 
         # BodyLength and CheckSum are computed by the engine on encode — skip them
         COMPUTED_TAGS = {TAG_BODY_LENGTH, TAG_CHECKSUM}
@@ -257,14 +281,20 @@ class DataDictionary:
                 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})")
+                raise InvalidMessage(
+                    f"Missing required header field: {name} ({tag})",
+                    reason=REJECT_REQUIRED_TAG_MISSING,
+                    ref_tag=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}"
+                    f"Missing required field: {name} ({tag}) in {msg_def.name}",
+                    reason=REJECT_REQUIRED_TAG_MISSING,
+                    ref_tag=tag,
                 )
 
         # Required trailer fields
@@ -273,7 +303,27 @@ class DataDictionary:
                 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})")
+                raise InvalidMessage(
+                    f"Missing required trailer field: {name} ({tag})",
+                    reason=REJECT_REQUIRED_TAG_MISSING,
+                    ref_tag=tag,
+                )
+
+        # Enum (out-of-range) field-value checks — header + body flat fields.
+        # MsgType is skipped (already validated against the message set above);
+        # tags without a defined enum no-op in validate_field_value.
+        if check_field_values:
+            fields = list(message.header.items()) + list(message.body.items())
+            for tag, value in fields:
+                if tag in COMPUTED_TAGS or tag == TAG_MSG_TYPE:
+                    continue
+                if not self.validate_field_value(tag, value):
+                    name = self._fields_by_number.get(tag, FieldDef(tag, str(tag), "STRING")).name
+                    raise InvalidMessage(
+                        f"Value {value!r} out of range for {name} ({tag})",
+                        reason=REJECT_VALUE_OUT_OF_RANGE,
+                        ref_tag=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."""
@@ -283,6 +333,28 @@ class DataDictionary:
         return value in fd.values
 
 
+# ---------------------------------------------------------------------------
+# Cached loading
+# ---------------------------------------------------------------------------
+
+@cache
+def _load_cached(resolved_path: str) -> DataDictionary:
+    return DataDictionary.from_xml(resolved_path)
+
+
+def load_data_dictionary(path: str | Path) -> DataDictionary:
+    """Load (and cache) a DataDictionary from *path*.
+
+    Multiple sessions sharing the same spec file reuse a single parsed
+    instance.  Raises :exc:`FileNotFoundError` with a clear message if the file
+    does not exist.
+    """
+    resolved = Path(path).expanduser()
+    if not resolved.is_file():
+        raise FileNotFoundError(f"DataDictionary spec not found: {path}")
+    return _load_cached(str(resolved.resolve()))
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/exceptions.py

@@ -1,8 +1,24 @@
 """FIX message exceptions."""
 
+from __future__ import annotations
+
 
 class InvalidMessage(Exception):
-    """Raised when a FIX message fails DataDictionary validation."""
+    """Raised when a FIX message fails DataDictionary validation.
+
+    Optionally carries the FIX SessionRejectReason (*reason*) and the offending
+    tag (*ref_tag*) so the session layer can emit a spec-compliant Reject.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        reason: int | None = None,
+        ref_tag: int | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.reason = reason
+        self.ref_tag = ref_tag
 
 
 class UnsupportedVersion(Exception):

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/field.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import OrderedDict
-from typing import Iterator
+from collections.abc import Iterator
 
 
 class Field:
@@ -106,7 +106,7 @@ class Group:
         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"]] = {}
+        self._groups: dict[int, list[Group]] = {}
 
     # ------------------------------------------------------------------
     # Simple field access (mirrors Message body API)
@@ -131,7 +131,7 @@ class Group:
     # Nested groups
     # ------------------------------------------------------------------
 
-    def add_group(self, count_tag: int, instance: "Group") -> None:
+    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)
@@ -139,7 +139,7 @@ class Group:
         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]":
+    def get_groups(self, count_tag: int) -> list[Group]:
         return self._groups.get(count_tag, [])
 
     def __repr__(self) -> str:

{fixcore_engine-0.2.1 → fixcore_engine-0.4.0}/fixcore/message/message.py

@@ -213,7 +213,7 @@ class Message:
         cls,
         raw: bytes,
         data_dictionary: DataDictionary | None = None,
-    ) -> "Message":
+    ) -> Message:
         """Parse *raw* SOH-delimited bytes into a Message.
 
         Raises ValueError on malformed input or checksum/body-length mismatch.
@@ -225,6 +225,7 @@ class Message:
         fields = _parse_fields(raw)
         if not fields:
             raise ValueError("Empty message")
+        _validate_field_order(fields)
 
         msg = cls()
 
@@ -264,8 +265,20 @@ class Message:
         return self.header.get_or(TAG_MSG_TYPE)
 
     def __repr__(self) -> str:
-        raw = self.encode()
-        return raw.replace(SOH, b"|").decode("latin-1")
+        try:
+            raw = self.encode()
+            return raw.replace(SOH, b"|").decode("latin-1")
+        except Exception:
+            # Partially-built message (e.g. no BeginString): show the fields
+            # we have without the computed BodyLength / CheckSum.
+            parts = [f"{t}={v}" for t, v in self.header.items()]
+            for tag in self._body_order:
+                if tag in self._body_groups:
+                    parts.append(f"{tag}={len(self._body_groups[tag])}")
+                else:
+                    parts.append(f"{tag}={self.body[tag]}")
+            parts += [f"{t}={v}" for t, v in self.trailer.items()]
+            return f"Message({'|'.join(parts)})"
 
 
 # ---------------------------------------------------------------------------
@@ -366,6 +379,22 @@ def _checksum(data: bytes) -> int:
     return sum(data) % 256
 
 
+def _validate_field_order(fields: list[tuple[int, str]]) -> None:
+    """Enforce the FIX positional invariants for the standard header/trailer.
+
+    Tag 8 (BeginString) must be first, 9 (BodyLength) second, 35 (MsgType)
+    third, and 10 (CheckSum) last.
+    """
+    if fields[0][0] != TAG_BEGIN_STRING:
+        raise ValueError("First field must be BeginString (tag 8)")
+    if len(fields) < 2 or fields[1][0] != TAG_BODY_LENGTH:
+        raise ValueError("Second field must be BodyLength (tag 9)")
+    if len(fields) < 3 or fields[2][0] != TAG_MSG_TYPE:
+        raise ValueError("Third field must be MsgType (tag 35)")
+    if fields[-1][0] != TAG_CHECKSUM:
+        raise ValueError("Last field must be CheckSum (tag 10)")
+
+
 def _parse_fields(raw: bytes) -> list[tuple[int, str]]:
     fields: list[tuple[int, str]] = []
     for part in raw.split(SOH):
@@ -381,22 +410,30 @@ def _parse_fields(raw: bytes) -> list[tuple[int, str]]:
 
 
 def _validate(raw: bytes, msg: Message) -> None:
-    # Validate checksum
+    # Locate the CheckSum field by its trailing SOH.  ``checksum_idx`` points at
+    # the SOH immediately before "10="; everything up to and including it is
+    # covered by the checksum.
     checksum_idx = raw.rfind(b"\x0110=")
     if checksum_idx == -1:
         raise ValueError("Missing CheckSum field (tag 10)")
+
+    # Validate checksum
     computed = _checksum(raw[: checksum_idx + 1])  # include the leading SOH
     declared = int(msg.trailer.get(TAG_CHECKSUM))
     if computed != declared:
         raise ValueError(f"CheckSum mismatch: computed {computed:03d}, got {declared:03d}")
 
-    # Validate body length
+    # Validate body length.  BodyLength counts the bytes from the start of tag 35
+    # up to (and including) the SOH before tag 10.  The start is anchored on the
+    # SOH positions of the first two fields (8=… then 9=…) rather than a literal
+    # search for "35=", which could otherwise match inside a field value.
     if msg.header.has(TAG_BODY_LENGTH):
         declared_len = int(msg.header.get(TAG_BODY_LENGTH))
-        # body length = bytes from tag 35 up to (not including) tag 10 field
-        start = raw.find(b"35=")
-        end = raw.rfind(b"\x0110=") + 1  # include the SOH before tag 10
-        actual_len = end - start
+        begin_string_soh = raw.find(b"\x01")
+        body_length_soh = raw.find(b"\x01", begin_string_soh + 1)
+        body_start = body_length_soh + 1  # first byte after "9=<len>\x01" (tag 35)
+        end = checksum_idx + 1            # include the SOH before tag 10
+        actual_len = end - body_start
         if actual_len != declared_len:
             raise ValueError(
                 f"BodyLength mismatch: declared {declared_len}, actual {actual_len}"