fixcore-engine 0.1.0__py3-none-any.whl

fixcore/__init__.py

@@ -0,0 +1,6 @@
+"""quickfix-py — pure Python FIX protocol engine."""
+
+from fixcore.application import Application
+from fixcore.session.session_id import SessionID
+
+__all__ = ["Application", "SessionID"]

fixcore/application.py

@@ -0,0 +1,47 @@
+"""Application interface — users subclass this to implement their trading logic."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fixcore.message.message import Message
+    from fixcore.session.session_id import SessionID
+
+
+class Application(ABC):
+    """Abstract base for FIX application callbacks.
+
+    All methods are called from within the asyncio event loop.  Blocking
+    implementations must delegate to ``asyncio.get_event_loop().run_in_executor``
+    to avoid stalling other sessions.
+    """
+
+    @abstractmethod
+    def on_create(self, session_id: SessionID) -> None:
+        """Called when a session is created."""
+
+    @abstractmethod
+    def on_logon(self, session_id: SessionID) -> None:
+        """Called after a successful Logon exchange."""
+
+    @abstractmethod
+    def on_logout(self, session_id: SessionID) -> None:
+        """Called after a session logs out or disconnects."""
+
+    @abstractmethod
+    def to_admin(self, message: Message, session_id: SessionID) -> None:
+        """Called before an admin message is sent; may mutate *message* in place."""
+
+    @abstractmethod
+    def to_app(self, message: Message, session_id: SessionID) -> None:
+        """Called before an application message is sent; may mutate *message* in place."""
+
+    @abstractmethod
+    def from_admin(self, message: Message, session_id: SessionID) -> None:
+        """Called when an admin message is received."""
+
+    @abstractmethod
+    def from_app(self, message: Message, session_id: SessionID) -> None:
+        """Called when an application message is received."""

fixcore/log/__init__.py

@@ -0,0 +1,7 @@
+"""Logging layer — session and message event logging."""
+
+from fixcore.log.base import Log, LogFactory
+from fixcore.log.file_log import FileLog, FileLogFactory
+from fixcore.log.screen import ScreenLog, ScreenLogFactory
+
+__all__ = ["Log", "LogFactory", "FileLog", "FileLogFactory", "ScreenLog", "ScreenLogFactory"]

fixcore/log/base.py

@@ -0,0 +1,27 @@
+"""Log / LogFactory abstract base classes."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from fixcore.session.session_id import SessionID
+
+
+class Log(ABC):
+    @abstractmethod
+    def on_incoming(self, message: str) -> None:
+        """Log a raw incoming message."""
+
+    @abstractmethod
+    def on_outgoing(self, message: str) -> None:
+        """Log a raw outgoing message."""
+
+    @abstractmethod
+    def on_event(self, text: str) -> None:
+        """Log a session event (connect, disconnect, error, etc.)."""
+
+
+class LogFactory(ABC):
+    @abstractmethod
+    def create(self, session_id: SessionID) -> Log:
+        """Return a Log instance for *session_id*."""

fixcore/log/factory.py

@@ -0,0 +1,10 @@
+"""LogFactory helpers — screen and file implementations already in their own modules.
+
+Re-exports everything under one roof so transport code only needs one import.
+"""
+
+from fixcore.log.base import Log, LogFactory
+from fixcore.log.file_log import FileLogFactory
+from fixcore.log.screen import ScreenLogFactory
+
+__all__ = ["Log", "LogFactory", "FileLogFactory", "ScreenLogFactory"]

fixcore/log/file_log.py

@@ -0,0 +1,70 @@
+"""File-backed Log implementation — appends timestamped entries to a log file."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from fixcore.log.base import Log, LogFactory
+from fixcore.session.session_id import SessionID
+
+
+def _session_filename(session_id: SessionID) -> str:
+    return (
+        f"{session_id.begin_string}-"
+        f"{session_id.sender_comp_id}-"
+        f"{session_id.target_comp_id}"
+        + (f"-{session_id.qualifier}" if session_id.qualifier else "")
+        + ".log"
+    )
+
+
+def _now() -> str:
+    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
+
+
+class FileLog(Log):
+    """Writes incoming messages, outgoing messages, and session events to a
+    single append-only log file.
+
+    Log line format::
+
+        20240101-12:00:00.000 : <incoming>  8=FIX.4.2|9=...|
+        20240101-12:00:00.001 : <outgoing>  8=FIX.4.2|9=...|
+        20240101-12:00:00.002 : --event--   Logon complete
+    """
+
+    def __init__(self, log_dir: str | Path, session_id: SessionID) -> None:
+        log_path = Path(log_dir) / _session_filename(session_id)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        self._fh = log_path.open("a", encoding="utf-8", buffering=1)  # line-buffered
+
+    def on_incoming(self, message: str) -> None:
+        self._fh.write(f"{_now()} : <incoming>  {message}\n")
+
+    def on_outgoing(self, message: str) -> None:
+        self._fh.write(f"{_now()} : <outgoing>  {message}\n")
+
+    def on_event(self, text: str) -> None:
+        self._fh.write(f"{_now()} : --event--   {text}\n")
+
+    def close(self) -> None:
+        """Flush and close the underlying file handle."""
+        self._fh.flush()
+        self._fh.close()
+
+    def __del__(self) -> None:
+        try:
+            self._fh.close()
+        except Exception:
+            pass
+
+
+class FileLogFactory(LogFactory):
+    """Creates a :class:`FileLog` for each session under *log_dir*."""
+
+    def __init__(self, log_dir: str | Path) -> None:
+        self._log_dir = Path(log_dir)
+
+    def create(self, session_id: SessionID) -> FileLog:
+        return FileLog(self._log_dir, session_id)

fixcore/log/screen.py

@@ -0,0 +1,32 @@
+"""Screen (stdout) log implementation."""
+
+from __future__ import annotations
+
+import sys
+from datetime import datetime, timezone
+
+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]
+
+
+class ScreenLog(Log):
+    def __init__(self, session_id: SessionID) -> None:
+        self._prefix = str(session_id)
+
+    def on_incoming(self, message: str) -> None:
+        print(f"{_now()} {self._prefix} <  {message}", file=sys.stdout)
+
+    def on_outgoing(self, message: str) -> None:
+        print(f"{_now()} {self._prefix}  > {message}", file=sys.stdout)
+
+    def on_event(self, text: str) -> None:
+        print(f"{_now()} {self._prefix} -- {text}", file=sys.stdout)
+
+
+class ScreenLogFactory(LogFactory):
+    def create(self, session_id: SessionID) -> ScreenLog:
+        return ScreenLog(session_id)

fixcore/message/__init__.py

@@ -0,0 +1,17 @@
+"""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.exceptions import (
+    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",
+    "FieldNotFound", "InvalidMessage", "UnsupportedMessageType", "UnsupportedVersion",
+    "Field", "FieldMap", "Group",
+    "Header", "Message", "Trailer",
+]

fixcore/message/cracker.py

@@ -0,0 +1,243 @@
+"""MessageCracker — mixin that dispatches fromApp messages to typed handler methods.
+
+Usage::
+
+    class MyApp(Application, MessageCracker):
+        def from_app(self, message: Message, session_id: SessionID) -> None:
+            self.crack(message, session_id)
+
+        def on_new_order_single(self, message: Message, session_id: SessionID) -> None:
+            clord_id = message.get_field(11)
+            ...
+
+        def on_execution_report(self, message: Message, session_id: SessionID) -> None:
+            ...
+
+Handler method names follow the convention ``on_<snake_case_message_name>``.  If
+no matching method is found, :meth:`on_message` is called, which raises
+:exc:`~fixcore.message.exceptions.UnsupportedMessageType` by default.
+
+Custom / venue-specific message types can be registered at class or instance
+level::
+
+    MessageCracker.register("U1", "on_custom_order")   # class-level
+"""
+
+from __future__ import annotations
+
+from fixcore.message.exceptions import UnsupportedMessageType
+from fixcore.message.message import Message
+from fixcore.session.session_id import SessionID
+
+
+# ---------------------------------------------------------------------------
+# MsgType → handler method name registry
+# ---------------------------------------------------------------------------
+
+# FIX 4.2 / 4.4 application messages
+_REGISTRY: dict[str, str] = {
+    # Orders
+    "D": "on_new_order_single",
+    "F": "on_order_cancel_request",
+    "G": "on_order_cancel_replace_request",
+    "H": "on_order_status_request",
+    "Q": "on_dont_know_trade",
+    # Executions / responses
+    "8": "on_execution_report",
+    "9": "on_order_cancel_reject",
+    # Lists
+    "E": "on_new_order_list",
+    "K": "on_list_cancel_request",
+    "L": "on_list_execute",
+    "M": "on_list_status_request",
+    "N": "on_list_status",
+    # Market data
+    "V": "on_market_data_request",
+    "W": "on_market_data_snapshot_full_refresh",
+    "X": "on_market_data_incremental_refresh",
+    "Y": "on_market_data_request_reject",
+    # Quotes
+    "R": "on_quote_request",
+    "S": "on_quote",
+    "Z": "on_quote_cancel",
+    "a": "on_quote_status_request",
+    "b": "on_mass_quote_acknowledgement",
+    "i": "on_mass_quote",
+    # Security / reference data
+    "c": "on_security_definition_request",
+    "d": "on_security_definition",
+    "e": "on_security_status_request",
+    "f": "on_security_status",
+    "g": "on_trading_session_status_request",
+    "h": "on_trading_session_status",
+    # Allocation / settlement
+    "J": "on_allocation",
+    "P": "on_allocation_ack",
+    "T": "on_settlement_instructions",
+    # News / email
+    "B": "on_news",
+    "C": "on_email",
+    # Business / application reject
+    "j": "on_business_message_reject",
+    # FIX 4.4 / 5.0 additions
+    "AB": "on_new_order_multileg",
+    "AC": "on_multileg_order_cancel_replace",
+    "AD": "on_trade_capture_report_request",
+    "AE": "on_trade_capture_report",
+    "AF": "on_order_mass_status_request",
+    "AG": "on_quote_request_reject",
+    "AH": "on_rfq_request",
+    "AI": "on_quote_status_report",
+    "AJ": "on_quote_response",
+    "AK": "on_confirmation",
+    "AL": "on_position_maintenance_request",
+    "AM": "on_position_maintenance_report",
+    "AN": "on_request_for_positions",
+    "AO": "on_request_for_positions_ack",
+    "AP": "on_position_report",
+    "AQ": "on_trade_capture_report_request_ack",
+    "AR": "on_trade_capture_report_ack",
+    "AS": "on_allocation_report",
+    "AT": "on_allocation_report_ack",
+    "AU": "on_confirmation_ack",
+    "AV": "on_settlement_instruction_request",
+    "AW": "on_assignment_report",
+    "AX": "on_collateral_request",
+    "AY": "on_collateral_assignment",
+    "AZ": "on_collateral_response",
+}
+
+
+class MessageCracker:
+    """Mixin providing MsgType-based dispatch for :meth:`Application.from_app`.
+
+    Combine with :class:`~fixcore.application.Application`::
+
+        class MyApp(Application, MessageCracker):
+            def from_app(self, message, session_id):
+                self.crack(message, session_id)
+
+            def on_new_order_single(self, message, session_id):
+                ...
+    """
+
+    # Instance-level overrides (populated by register_instance or subclass __init__)
+    _instance_registry: dict[str, str]
+
+    # ------------------------------------------------------------------
+    # Dispatch
+    # ------------------------------------------------------------------
+
+    def crack(self, message: Message, session_id: SessionID) -> None:
+        """Dispatch *message* to the appropriate typed handler.
+
+        Resolution order:
+        1. Instance registry (set via :meth:`register_instance`)
+        2. Class-level registry (set via :meth:`register`)
+        3. :meth:`on_message` fallback
+        """
+        msg_type = message.msg_type
+
+        # Instance overrides take precedence
+        instance_reg = getattr(self, "_instance_registry", {})
+        handler_name = instance_reg.get(msg_type) or _REGISTRY.get(msg_type)
+
+        if handler_name:
+            handler = getattr(self, handler_name, None)
+            if handler is not None:
+                handler(message, session_id)
+                return
+
+        self.on_message(message, session_id)
+
+    def on_message(self, message: Message, session_id: SessionID) -> None:
+        """Fallback called when no specific handler is found.
+
+        Raises :exc:`~fixcore.message.exceptions.UnsupportedMessageType`
+        by default.  Override to handle all unknown message types generically.
+        """
+        raise UnsupportedMessageType(message.msg_type)
+
+    # ------------------------------------------------------------------
+    # Registration helpers
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def register(cls, msg_type: str, handler_name: str) -> None:
+        """Register a class-wide handler for *msg_type*.
+
+        Example::
+
+            MessageCracker.register("U1", "on_custom_order")
+        """
+        _REGISTRY[msg_type] = handler_name
+
+    def register_instance(self, msg_type: str, handler_name: str) -> None:
+        """Register a handler for *msg_type* on this instance only."""
+        if not hasattr(self, "_instance_registry"):
+            self._instance_registry = {}
+        self._instance_registry[msg_type] = handler_name
+
+    # ------------------------------------------------------------------
+    # Default typed handlers (all call on_message — override to handle)
+    # ------------------------------------------------------------------
+
+    def on_new_order_single(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_execution_report(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_order_cancel_request(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_order_cancel_reject(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_order_cancel_replace_request(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_order_status_request(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_market_data_request(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_market_data_snapshot_full_refresh(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_market_data_incremental_refresh(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_market_data_request_reject(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_quote_request(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_quote(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_news(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+    def on_business_message_reject(self, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+
+
+# ---------------------------------------------------------------------------
+# Auto-generate default handlers for any registered handler name that doesn't
+# already have an explicit implementation on the class.
+# ---------------------------------------------------------------------------
+
+def _make_default_handler(name: str):  # noqa: ANN202
+    def handler(self: MessageCracker, message: Message, session_id: SessionID) -> None:
+        self.on_message(message, session_id)
+    handler.__name__ = name
+    handler.__qualname__ = f"MessageCracker.{name}"
+    return handler
+
+
+for _handler_name in set(_REGISTRY.values()):
+    if not hasattr(MessageCracker, _handler_name):
+        setattr(MessageCracker, _handler_name, _make_default_handler(_handler_name))