fixcore-engine 0.2.0__tar.gz → 0.3.0__tar.gz

{fixcore_engine-0.2.0/fixcore_engine.egg-info → fixcore_engine-0.3.0}/PKG-INFO

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

{fixcore_engine-0.2.0 → fixcore_engine-0.3.0}/fixcore/message/__init__.py

@@ -1,7 +1,9 @@
 """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,
 )
@@ -10,7 +12,7 @@ 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.0 → fixcore_engine-0.3.0}/fixcore/message/data_dictionary.py

@@ -4,10 +4,15 @@ from __future__ import annotations
 
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass, field
+from functools import lru_cache
 from pathlib import Path
 
 from fixcore.message.exceptions import InvalidMessage
 
+# SessionRejectReason codes (FIX session-level)
+REJECT_REQUIRED_TAG_MISSING = 1
+REJECT_INVALID_MSGTYPE = 11
+
 # Imported here to avoid circular import at module level; also used as constants
 TAG_BODY_LENGTH = 9
 TAG_CHECKSUM = 10
@@ -242,11 +247,19 @@ class DataDictionary:
 
         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 +270,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 +292,11 @@ 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,
+                )
 
     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 +306,28 @@ class DataDictionary:
         return value in fd.values
 
 
+# ---------------------------------------------------------------------------
+# Cached loading
+# ---------------------------------------------------------------------------
+
+@lru_cache(maxsize=None)
+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.0 → fixcore_engine-0.3.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.0 → fixcore_engine-0.3.0}/fixcore/message/message.py

@@ -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}"