onesecondtrader 0.23.0__tar.gz → 0.24.0__tar.gz

{onesecondtrader-0.23.0 → onesecondtrader-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.23.0
+Version: 0.24.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 License-File: LICENSE
 Author: Nils P. Kujath

{onesecondtrader-0.23.0 → onesecondtrader-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.23.0"
+version = "0.24.0"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

onesecondtrader-0.24.0/src/onesecondtrader/core/__init__.py

@@ -0,0 +1,47 @@
+from .domain_models import BarPeriod, OrderSide, OrderType
+from .event_bus import EventBus
+from .event_messages import (
+    AcceptedOrderCancellation,
+    AcceptedOrderModification,
+    AcceptedOrderSubmission,
+    BrokerRequestEventBase,
+    BrokerResponseEventBase,
+    ConfirmedOrderExpired,
+    ConfirmedOrderFilled,
+    EventBase,
+    MarketEventBase,
+    NewBar,
+    RejectedOrderCancellation,
+    RejectedOrderModification,
+    RejectedOrderSubmission,
+    RequestOrderCancellation,
+    RequestOrderModification,
+    RequestOrderSubmission,
+)
+from .event_publisher import EventPublisher
+from .event_subscriber import EventSubscriber
+
+__all__ = [
+    "BarPeriod",
+    "OrderSide",
+    "OrderType",
+    "EventBus",
+    "AcceptedOrderCancellation",
+    "AcceptedOrderModification",
+    "AcceptedOrderSubmission",
+    "BrokerRequestEventBase",
+    "BrokerResponseEventBase",
+    "ConfirmedOrderExpired",
+    "ConfirmedOrderFilled",
+    "EventBase",
+    "MarketEventBase",
+    "NewBar",
+    "RejectedOrderCancellation",
+    "RejectedOrderModification",
+    "RejectedOrderSubmission",
+    "RequestOrderCancellation",
+    "RequestOrderModification",
+    "RequestOrderSubmission",
+    "EventPublisher",
+    "EventSubscriber",
+]

onesecondtrader-0.24.0/src/onesecondtrader/core/domain_models.py

@@ -0,0 +1,30 @@
+"""
+---
+This module defines the core domain models used throughout the system.
+
+Domain models are enumerations that define the shared vocabulary of the trading system.
+They provide a fixed set of valid values for core concepts and are used across all
+system components to ensure consistency and type safety.
+---
+"""
+
+import enum
+
+
+class OrderType(enum.Enum):
+    LIMIT = enum.auto()
+    MARKET = enum.auto()
+    STOP = enum.auto()
+    STOP_LIMIT = enum.auto()
+
+
+class OrderSide(enum.Enum):
+    BUY = enum.auto()
+    SELL = enum.auto()
+
+
+class BarPeriod(enum.Enum):
+    SECOND = 32
+    MINUTE = 33
+    HOUR = 34
+    DAY = 35

onesecondtrader-0.24.0/src/onesecondtrader/core/event_bus.py

@@ -0,0 +1,60 @@
+"""
+Read first: [Event Messages](./event_messages.md).
+
+---
+This module defines the central event bus for publish-subscribe communication.
+
+EventBus is the core messaging infrastructure that routes events between system
+components.
+Subscribers register interest in specific event types and receive events when publishers
+dispatch them.
+Event routing uses exact type matching, so subscribing to a base class will not receive
+events of derived types.
+---
+"""
+
+import collections
+import threading
+import typing
+
+from .event_messages import EventBase
+
+
+@typing.runtime_checkable
+class EventSubscriberLike(typing.Protocol):
+    def receive(self, event: EventBase) -> None: ...
+    def wait_until_idle(self) -> None: ...
+
+
+class EventBus:
+    def __init__(self) -> None:
+        self._per_event_subscriptions: collections.defaultdict[
+            type[EventBase], set[EventSubscriberLike]
+        ] = collections.defaultdict(set)
+        self._subscribers: set[EventSubscriberLike] = set()
+        self._lock: threading.Lock = threading.Lock()
+
+    def subscribe(
+        self, subscriber: EventSubscriberLike, event_type: type[EventBase]
+    ) -> None:
+        with self._lock:
+            self._subscribers.add(subscriber)
+            self._per_event_subscriptions[event_type].add(subscriber)
+
+    def unsubscribe(self, subscriber: EventSubscriberLike) -> None:
+        with self._lock:
+            for set_of_event_subscribers in self._per_event_subscriptions.values():
+                set_of_event_subscribers.discard(subscriber)
+            self._subscribers.discard(subscriber)
+
+    def publish(self, event: EventBase) -> None:
+        with self._lock:
+            subscribers = self._per_event_subscriptions[type(event)].copy()
+        for subscriber in subscribers:
+            subscriber.receive(event)
+
+    def wait_until_system_idle(self) -> None:
+        with self._lock:
+            subscribers = self._subscribers.copy()
+        for subscriber in subscribers:
+            subscriber.wait_until_idle()

onesecondtrader-0.24.0/src/onesecondtrader/core/event_messages.py

@@ -0,0 +1,128 @@
+"""
+Read first: [Domain Models](./domain_models.md).
+
+---
+This module defines the event messages used throughout the system.
+
+Event messages are immutable dataclasses used for communication between system
+components
+They are semantically grouped into market, broker request, and broker
+response events via inheritance from dedicated base classes.
+---
+"""
+
+import dataclasses
+import pandas as pd
+import uuid
+
+from .domain_models import BarPeriod, OrderSide, OrderType
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class EventBase:
+    ts_event: pd.Timestamp
+    ts_created: pd.Timestamp = dataclasses.field(
+        default_factory=lambda: pd.Timestamp.now(tz="UTC")
+    )
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class MarketEventBase(EventBase):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerRequestEventBase(EventBase):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerResponseEventBase(EventBase):
+    ts_broker: pd.Timestamp
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class NewBar(MarketEventBase):
+    symbol: str
+    bar_period: BarPeriod
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RequestOrderSubmission(BrokerRequestEventBase):
+    order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    symbol: str
+    order_type: OrderType
+    side: OrderSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RequestOrderCancellation(BrokerRequestEventBase):
+    symbol: str
+    order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RequestOrderModification(BrokerRequestEventBase):
+    symbol: str
+    order_id: uuid.UUID
+    quantity: float | None = None
+    limit_price: float | None = None
+    stop_price: float | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class AcceptedOrderSubmission(BrokerResponseEventBase):
+    order_id: uuid.UUID
+    broker_order_id: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class AcceptedOrderModification(BrokerResponseEventBase):
+    order_id: uuid.UUID
+    broker_order_id: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class AcceptedOrderCancellation(BrokerResponseEventBase):
+    order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RejectedOrderSubmission(BrokerResponseEventBase):
+    order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RejectedOrderModification(BrokerResponseEventBase):
+    order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class RejectedOrderCancellation(BrokerResponseEventBase):
+    order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class ConfirmedOrderFilled(BrokerResponseEventBase):
+    fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    broker_fill_id: str | None = None
+    associated_order_id: uuid.UUID
+    symbol: str
+    side: OrderSide
+    quantity_filled: float
+    fill_price: float
+    commission: float
+    exchange: str = "SIMULATED"
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class ConfirmedOrderExpired(BrokerResponseEventBase):
+    order_id: uuid.UUID

onesecondtrader-0.24.0/src/onesecondtrader/core/event_publisher.py

@@ -0,0 +1,23 @@
+"""
+Read first: [Event Bus](./event_bus.md), [Event Messages](./event_messages.md).
+
+---
+This module defines the base class for components that publish events.
+
+EventPublisher provides a minimal interface for publishing events to the event bus.
+Components that only publish events inherit from this class directly.
+Components that both subscribe and publish inherit from both EventSubscriber and
+EventPublisher.
+---
+"""
+
+from .event_bus import EventBus
+from .event_messages import EventBase
+
+
+class EventPublisher:
+    def __init__(self, event_bus: EventBus) -> None:
+        self._event_bus = event_bus
+
+    def _publish(self, event: EventBase) -> None:
+        self._event_bus.publish(event)

onesecondtrader-0.24.0/src/onesecondtrader/core/event_subscriber.py

@@ -0,0 +1,76 @@
+"""
+Read first: [Event Bus](./event_bus.md), [Event Messages](./event_messages.md).
+
+---
+This module defines the base class for components that subscribe to events.
+
+EventSubscriber provides a threaded event loop that receives events from the event bus.
+Each subscriber runs in its own thread and processes events from its internal queue.
+Components that only subscribe inherit from this class directly.
+Components that both subscribe and publish inherit from both EventSubscriber and
+EventPublisher.
+---
+"""
+
+import abc
+import queue
+import threading
+
+from .event_bus import EventBus
+from .event_messages import EventBase
+
+
+class EventSubscriber(abc.ABC):
+    def __init__(self, event_bus: EventBus) -> None:
+        self._event_bus = event_bus
+        self._queue: queue.Queue[EventBase | None] = queue.Queue()
+        self._running = True
+        self._thread = threading.Thread(
+            target=self._event_loop, name=self.__class__.__name__
+        )
+        self._thread.start()
+
+    def receive(self, event: EventBase) -> None:
+        if self._running:
+            self._queue.put(event)
+
+    def wait_until_idle(self) -> None:
+        if not self._running:
+            return
+        self._queue.join()
+
+    def shutdown(self) -> None:
+        if not self._running:
+            return
+        self._running = False
+        self._event_bus.unsubscribe(self)
+        self._queue.put(None)
+        if threading.current_thread() is not self._thread:
+            self._thread.join()
+
+    def _subscribe(self, *event_types: type[EventBase]) -> None:
+        for event_type in event_types:
+            self._event_bus.subscribe(self, event_type)
+
+    def _event_loop(self) -> None:
+        while True:
+            event = self._queue.get()
+            if event is None:
+                self._queue.task_done()
+                break
+            try:
+                self._on_event(event)
+            except Exception:
+                self._on_exception()
+            finally:
+                self._queue.task_done()
+        self._cleanup()
+
+    def _on_exception(self) -> None:
+        pass
+
+    def _cleanup(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def _on_event(self, event: EventBase) -> None: ...

onesecondtrader-0.23.0/src/onesecondtrader/core/component.py

@@ -1,119 +0,0 @@
-"""
-Read first: [`events.py`](./events.md), [`eventbus.py`](./eventbus.md).
-
----
-This module defines the `Component` class.
-
-In an event-driven system, components interact exclusively via event messages.
-The `Component` class is an abstract base class that defines a common interface for
-publishing and receiving such messages and is intended to be subclassed by all system
-components.
----
-"""
-
-import abc
-import queue
-import threading
-
-from .events import Event
-from .eventbus import EventBus
-
-
-class Component(abc.ABC):
-    """
-    Abstract base class for all system components.
-
-    Incoming events are delivered via `receive()` and stored in an internal queue.
-    A dedicated thread runs an event loop that consumes queued events and dispatches
-    them to `_process()`, which subclasses must implement.
-    For publication, `publish()` forwards events to the event bus.
-    The `join_queue()` method is used by the event bus to block until all queued events
-    have been processed, which is useful for deterministic, stepwise execution in
-    backtesting.
-    """
-
-    def __init__(self, eventbus: EventBus) -> None:
-        """
-        Initialize the component and start its event-loop thread.
-
-        Stores a reference to the event bus, creates an internal queue for incoming
-        events, and starts a non-daemon thread for the event loop that runs until
-        shutdown.
-        """
-        self._event_bus = eventbus
-        self._incoming_event_queue: queue.Queue[Event | None] = queue.Queue()
-        self._thread: threading.Thread = threading.Thread(
-            target=self._event_loop,
-            name=self.__class__.__name__,
-            daemon=False,
-        )
-        self._thread.start()
-
-    def publish(self, event: Event) -> None:
-        """
-        Wrapper for the event bus's `publish()` method.
-
-        For convenience, this method can be used by subclasses to publish events via the
-        event bus's publication mechanism.
-        """
-        self._event_bus.publish(event)
-
-    def receive(self, event: Event) -> None:
-        """
-        Store incoming events in the component's queue.
-
-        This method is typically called by the event bus when an event is published that
-        the component has subscribed to.
-        It simply puts the event in the queue for processing by the subscribed
-        component.
-        """
-        self._incoming_event_queue.put(event)
-
-    def join_queue(self) -> None:
-        """
-        Block until all queued events have been processed.
-
-        This method is used by the event bus to block until all queued events have been
-        processed.
-        This is useful for deterministic, stepwise execution in backtesting.
-        """
-        self._incoming_event_queue.join()
-
-    def _event_loop(self) -> None:
-        """
-        Event-processing loop executed in the component’s dedicated thread.
-
-        The loop continuously retrieves events from the `incoming_event_queue`,
-        processes each event via `_process()`, and signals completion with
-        `task_done()`.
-        Execution terminates upon receipt of a `None` sentinel, at which point
-        `_shutdown()` is invoked before exiting the thread to ensure proper cleanup.
-        """
-        while True:
-            incoming_event = self._incoming_event_queue.get()
-            if incoming_event is None:
-                self._shutdown()
-                self._incoming_event_queue.task_done()
-                break
-            self._process(incoming_event)
-            self._incoming_event_queue.task_done()
-
-    @abc.abstractmethod
-    def _process(self, event: Event) -> None:
-        """
-        Process a single event.
-
-        This method is invoked by the event loop for each incoming event.
-        Subclasses must implement it to define event-handling behavior.
-        """
-        pass
-
-    def _shutdown(self) -> None:
-        """
-        Perform cleanup when the component is shutting down.
-
-        Called by `_event_loop()` when a `None` sentinel is received.
-        Subclasses may override this method to perform cleanup tasks such as closing
-        files or connections before the thread exits.
-        """
-        pass

onesecondtrader-0.23.0/src/onesecondtrader/core/eventbus.py

@@ -1,85 +0,0 @@
-"""
-Read first: [`events.py`](./events.md), [`component.py`](./component.md).
-
----
-This module defines the `EventBus` class.
-
-The event bus provides a publish–subscribe mechanism for event-driven systems.
-It maintains subscriptions between event types and components and delivers
-published events to all subscribed components in a thread-safe manner.
----
-"""
-
-import collections
-import threading
-
-from .component import Component
-from .events import Event
-
-
-class EventBus:
-    """
-    Central event-dispatch mechanism for the system.
-
-    The event bus manages subscriptions between event types and components and
-    forwards published events to all subscribed components.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initialize the event bus.
-
-        Sets up internal data structures for managing subscriptions and registered
-        components and initializes a lock to ensure thread-safe access.
-        """
-        self._subscriptions: collections.defaultdict[type[Event], set[Component]] = (
-            collections.defaultdict(set)
-        )
-        self._components: set[Component] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(self, subscriber: Component, *event_types: type[Event]) -> None:
-        """
-        Subscribe a component to one or more event types.
-
-        The subscriber will receive all future events whose type matches one of the
-        specified event types.
-        """
-        with self._lock:
-            self._components.add(subscriber)
-            for event_type in event_types:
-                self._subscriptions[event_type].add(subscriber)
-
-    def unsubscribe(self, subscriber: Component) -> None:
-        """
-        Remove a component from all event subscriptions.
-
-        After unsubscription, the component will no longer receive published events.
-        """
-        with self._lock:
-            for component_set in self._subscriptions.values():
-                component_set.discard(subscriber)
-            self._components.discard(subscriber)
-
-    def publish(self, event: Event) -> None:
-        """
-        Publish an event to all subscribed components.
-
-        The event is delivered to each subscriber by invoking its `receive()` method.
-        """
-        with self._lock:
-            components = self._subscriptions[type(event)].copy()
-        for component in components:
-            component.receive(event)
-
-    def wait_until_idle(self) -> None:
-        """
-        Block until all components have processed their queued events.
-
-        This method is primarily used in backtesting to enforce deterministic,
-        system-wide synchronization.
-        """
-        with self._lock:
-            components = self._components.copy()
-        for component in components:
-            component.join_queue()

onesecondtrader-0.23.0/src/onesecondtrader/core/events.py

@@ -1,224 +0,0 @@
-"""
-Read first: [`models.py`](./models.md).
-
----
-This module provides all event message classes used in the system.
-
-In an event-driven system, components communicate by sending event messages to each
-other. An event message is an immutable object that contains all information relevant
-to a specific occurrence, such as incoming market data, order submissions, fills, or
-other domain-specific events.
----
-"""
-
-import dataclasses
-import uuid
-
-import pandas as pd
-
-from .models import BarPeriod, OrderType, OrderSide
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class Event:
-    """
-    Base class for all event messages in the system.
-
-    All events include a timestamp indicating when the event was created or received.
-    Subclasses define specific event types with additional fields relevant to that
-    event.
-    """
-
-    ts_event: pd.Timestamp = dataclasses.field(
-        default_factory=lambda: pd.Timestamp.now(tz="UTC")
-    )
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class ReceivedNewBar(Event):
-    """
-    Event indicating a new bar of market data has been received.
-
-    Contains OHLCV data for a specific symbol and bar period. This event is typically
-    emitted by data feed components when new market data arrives.
-    """
-
-    ts_event: pd.Timestamp
-    symbol: str
-    bar_period: BarPeriod
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class ProcessedBar(Event):
-    """
-    Event indicating a bar has been processed and enriched with indicator values.
-
-    Contains the same OHLCV data as ReceivedNewBar, plus a dictionary of computed
-    indicator values. This event is typically emitted after strategies or other
-    components have calculated technical indicators for the bar.
-    """
-
-    ts_event: pd.Timestamp
-    symbol: str
-    bar_period: BarPeriod
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-    indicators: dict[str, float] = dataclasses.field(default_factory=dict)
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RequestOrderSubmission(Event):
-    """
-    Event requesting submission of a new order with the broker.
-
-    Contains all parameters needed to submit an order, including symbol, order type,
-    side, quantity, and optional limit/stop prices. A unique order_id is automatically
-    generated if not provided.
-    """
-
-    order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    symbol: str
-    order_type: OrderType
-    side: OrderSide
-    quantity: float
-    limit_price: float | None = None
-    stop_price: float | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RequestOrderModification(Event):
-    """
-    Event requesting modification of an existing order.
-
-    Identifies the order to modify by order_id and symbol. Any of quantity, limit_price,
-    or stop_price can be updated by providing new values.
-    """
-
-    symbol: str
-    order_id: uuid.UUID
-    quantity: float | None = None
-    limit_price: float | None = None
-    stop_price: float | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RequestOrderCancellation(Event):
-    """
-    Event requesting cancellation of an existing order.
-
-    Identifies the order to cancel by order_id and symbol.
-    """
-
-    symbol: str
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderSubmission(Event):
-    """
-    Event indicating the broker has accepted an order submission.
-
-    Contains the system's order_id and optionally the broker's order_id if provided
-    by the broker.
-    """
-
-    order_id: uuid.UUID
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderModification(Event):
-    """
-    Event indicating the broker has accepted an order modification.
-
-    Contains the system's order_id and optionally the broker's order_id if provided
-    by the broker.
-    """
-
-    order_id: uuid.UUID
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderCancellation(Event):
-    """
-    Event indicating the broker has accepted an order cancellation.
-
-    Contains the system's order_id for the cancelled order.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderSubmission(Event):
-    """
-    Event indicating the broker has rejected an order submission.
-
-    Contains the system's order_id for the rejected order.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderModification(Event):
-    """
-    Event indicating the broker has rejected an order modification.
-
-    Contains the system's order_id for the order that could not be modified.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderCancellation(Event):
-    """
-    Event indicating the broker has rejected an order cancellation.
-
-    Contains the system's order_id for the order that could not be cancelled.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderFilled(Event):
-    """
-    Event indicating an order has been filled (fully or partially).
-
-    Contains details about the fill including quantity, price, commission, and the
-    associated order. A unique fill_id is automatically generated if not provided.
-    The broker may optionally provide a broker_fill_id.
-    """
-
-    fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    broker_fill_id: str | None = None
-    associated_order_id: uuid.UUID
-    symbol: str
-    side: OrderSide
-    quantity_filled: float
-    fill_price: float
-    commission: float
-    exchange: str = "SIMULATED"
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderExpired(Event):
-    """
-    Event indicating an order has expired without being filled.
-
-    Contains the system's order_id for the expired order. This typically occurs for
-    time-limited orders that were not filled before their expiration time.
-    """
-
-    order_id: uuid.UUID

onesecondtrader-0.23.0/src/onesecondtrader/core/models.py

@@ -1,70 +0,0 @@
-"""
----
-This module provides core domain models used throughout the system.
-
-Domain models are enumerations that define the vocabulary and valid values for key
-concepts in the trading system. These models are used across all components to ensure
-type safety and consistency when representing domain-specific concepts.
----
-"""
-
-import enum
-
-
-class BarPeriod(enum.Enum):
-    """
-    Time period for aggregating market data into bars.
-
-    Defines the standard time intervals used for OHLCV bar data.
-    Each bar represents market activity aggregated over the specified period.
-    """
-
-    SECOND = 32
-    MINUTE = 33
-    HOUR = 34
-    DAY = 35
-
-
-class OrderType(enum.Enum):
-    """
-    Type of order to submit to the broker.
-
-    Defines the execution behavior for an order.
-    Market orders execute immediately at current market price.
-    Limit orders execute only at a specified price or better.
-    Stop orders become market orders when a trigger price is reached.
-    Stop-limit orders become limit orders when a trigger price is reached.
-    """
-
-    MARKET = enum.auto()
-    LIMIT = enum.auto()
-    STOP = enum.auto()
-    STOP_LIMIT = enum.auto()
-
-
-class OrderSide(enum.Enum):
-    """
-    Direction of an order or position.
-
-    Indicates whether an order is buying or selling a security.
-    """
-
-    BUY = enum.auto()
-    SELL = enum.auto()
-
-
-class InputSource(enum.Enum):
-    """
-    Source field from bar data to use as input for indicators.
-
-    Specifies which component of OHLCV bar data should be used when calculating
-    technical indicators.
-    For example, many indicators use CLOSE prices per default, but could also be
-    calculated based on other fields.
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    VOLUME = enum.auto()