onesecondtrader 0.21.0__tar.gz → 0.23.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.21.0
+Version: 0.23.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.21.0 → onesecondtrader-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.21.0"
+version = "0.23.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.23.0/src/onesecondtrader/core/component.py

@@ -0,0 +1,119 @@
+"""
+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

@@ -0,0 +1,85 @@
+"""
+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

@@ -0,0 +1,224 @@
+"""
+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

@@ -0,0 +1,70 @@
+"""
+---
+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()

onesecondtrader-0.21.0/src/onesecondtrader/core.py

@@ -1,234 +0,0 @@
-"""
-Core module containing the backbone of OneSecondTrader's event-driven architecture.
-"""
-
-import abc
-import dataclasses
-import enum
-import logging
-import pandas as pd
-import queue
-import threading
-import uuid
-
-from collections import defaultdict
-
-
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s - %(levelname)s - %(threadName)s - %(message)s",
-)
-logger = logging.getLogger("onesecondtrader")
-
-
-class Models:
-    """
-    Namespace for all models.
-    """
-
-    class RecordType(enum.Enum):
-        OHLCV_1S = 32
-        OHLCV_1M = 33
-        OHLCV_1H = 34
-        OHLCV_1D = 35
-
-    class OrderSide(enum.Enum):
-        BUY = enum.auto()
-        SELL = enum.auto()
-
-    class OrderType(enum.Enum):
-        MARKET = enum.auto()
-        LIMIT = enum.auto()
-        STOP = enum.auto()
-        STOP_LIMIT = enum.auto()
-
-    class RejectionReason(enum.Enum):
-        ORDER_ALREADY_FILLED = enum.auto()
-        ORDER_ALREADY_CANCELLED = enum.auto()
-        ORDER_PENDING_EXECUTION = enum.auto()
-        INSUFFICIENT_FUNDS = enum.auto()
-        MARKET_CLOSED = enum.auto()
-        UNKNOWN = enum.auto()
-
-    class TimeInForce(enum.Enum):
-        GTC = enum.auto()
-        DAY = enum.auto()
-        IOC = enum.auto()
-        FOK = enum.auto()
-
-
-class Events:
-    """
-    Namespace for all events.
-    """
-
-    # BASE EVENT
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class BaseEvent:
-        ts_event: pd.Timestamp = dataclasses.field(
-            default_factory=lambda: pd.Timestamp.now(tz="UTC")
-        )
-
-    # SYSTEM EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class SystemEvent(BaseEvent):
-        pass
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class SystemShutdown(SystemEvent):
-        pass
-
-    # MARKET EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class MarketEvent(BaseEvent):
-        pass
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class IncomingBar(MarketEvent):
-        ts_event: pd.Timestamp
-        symbol: str
-        record_type: Models.RecordType
-        open: float
-        high: float
-        low: float
-        close: float
-        volume: int | None = None
-
-    # BROKER REQUESTS EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class BrokerRequestEvent(BaseEvent):
-        pass
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class SubmitOrder(BrokerRequestEvent):
-        order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-        symbol: str
-        order_type: Models.OrderType
-        side: Models.OrderSide
-        quantity: float
-        limit_price: float | None = None
-        stop_price: float | None = None
-        time_in_force: Models.TimeInForce = Models.TimeInForce.GTC
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class ModifyOrder(BrokerRequestEvent):
-        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 CancelOrder(BrokerRequestEvent):
-        order_id: uuid.UUID
-
-    # BROKER RESPONSE EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class BrokerResponseEvent(BaseEvent):
-        ts_broker: pd.Timestamp
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class OrderSubmitted(BrokerResponseEvent):
-        order_id: uuid.UUID
-        broker_order_id: str | None = None
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class OrderModified(BrokerResponseEvent):
-        order_id: uuid.UUID
-        broker_order_id: str | None = None
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class Fill(BrokerResponseEvent):
-        fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-        broker_fill_id: str | None = None
-        associated_order_id: uuid.UUID
-        symbol: str
-        side: Models.OrderSide
-        quantity_filled: float
-        fill_price: float
-        commission: float
-        exchange: str = "SIMULATED"
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class OrderRejected(BrokerResponseEvent):
-        order_id: uuid.UUID
-        reason: Models.RejectionReason
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class OrderCancelled(BrokerResponseEvent):
-        order_id: uuid.UUID
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class OrderExpired(BrokerResponseEvent):
-        order_id: uuid.UUID
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class CancelRejected(BrokerResponseEvent):
-        order_id: uuid.UUID
-        reason: Models.RejectionReason
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class ModifyRejected(BrokerResponseEvent):
-        order_id: uuid.UUID
-        reason: Models.RejectionReason
-
-
-class BaseConsumer(abc.ABC):
-    """
-    Base class for all consumers.
-    """
-
-    def __init__(self) -> None:
-        self._queue: queue.Queue[Events.BaseEvent] = queue.Queue()
-        self._thread = threading.Thread(
-            target=self._consume, name=self.__class__.__name__, daemon=True
-        )
-        self._thread.start()
-
-    @abc.abstractmethod
-    def on_event(self, event: Events.BaseEvent) -> None:
-        pass
-
-    def receive(self, event: Events.BaseEvent) -> None:
-        self._queue.put(event)
-
-    def _consume(self) -> None:
-        while True:
-            event = self._queue.get()
-            if isinstance(event, Events.SystemShutdown):
-                break
-            self.on_event(event)
-
-
-class EventBus:
-    """
-    Event bus for publishing events to the consumers subscribed to them.
-    """
-
-    def __init__(self) -> None:
-        self._subscriptions: defaultdict[type[Events.BaseEvent], list[BaseConsumer]] = (
-            defaultdict(list)
-        )
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(self, subscriber: BaseConsumer, event_type: type[Events.BaseEvent]):
-        with self._lock:
-            if subscriber not in self._subscriptions[event_type]:
-                self._subscriptions[event_type].append(subscriber)
-
-    def unsubscribe(self, subscriber: BaseConsumer):
-        with self._lock:
-            for consumer_list in self._subscriptions.values():
-                if subscriber in consumer_list:
-                    consumer_list.remove(subscriber)
-
-    def publish(self, event: Events.BaseEvent) -> None:
-        with self._lock:
-            consumers = list(self._subscriptions[type(event)])
-        for consumer in consumers:
-            consumer.receive(event)
-
-
-event_bus = EventBus()
-"""
-Global event bus instance.
-"""

onesecondtrader-0.21.0/src/onesecondtrader/datafeeds.py

@@ -1,172 +0,0 @@
-import abc
-import pandas as pd
-import threading
-
-from pathlib import Path
-from onesecondtrader.core import Events, Models, event_bus, logger
-
-
-class DatafeedBase(abc.ABC):
-    """
-    Base class for all datafeeds.
-    """
-
-    def __init__(self) -> None:
-        self._is_connected: bool = False
-        self._watched_symbols: set[tuple[str, Models.RecordType]] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    @abc.abstractmethod
-    def watch(self, symbols: list[tuple[str, Models.RecordType]]) -> bool:
-        pass
-
-    @abc.abstractmethod
-    def unwatch(self, symbols: list[str]) -> None:
-        pass
-
-
-class SimulatedDatafeedCSV(DatafeedBase):
-    """
-    CSV-based simulated datafeed for backtesting.
-    """
-
-    csv_path: str | Path = ""
-    artificial_delay: float = 0.0
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._stop_event = threading.Event()
-        self._streaming_thread: threading.Thread | None = None
-        self._data_iterator: pd.io.parsers.readers.TextFileReader | None = None
-        self._connected_path: str | Path = ""
-
-    def watch(self, symbols: list[tuple[str, Models.RecordType]]) -> bool:
-        with self._lock:
-            if not self._is_connected:
-                try:
-                    self._data_iterator = pd.read_csv(
-                        Path(self.csv_path),
-                        usecols=[
-                            "ts_event",
-                            "rtype",
-                            "open",
-                            "high",
-                            "low",
-                            "close",
-                            "volume",
-                            "symbol",
-                        ],
-                        dtype={
-                            "ts_event": int,
-                            "rtype": int,
-                            "open": int,
-                            "high": int,
-                            "low": int,
-                            "close": int,
-                            "volume": int,
-                            "symbol": str,
-                        },
-                        chunksize=1,
-                    )
-                    self._is_connected = True
-                    self._connected_path = self.csv_path
-                    logger.info(
-                        f"{self.__class__.__name__} connected to {self.csv_path}"
-                    )
-                except Exception as e:
-                    logger.error(f"{self.__class__.__name__} failed to connect: {e}")
-                    self._data_iterator = None
-                    self._is_connected = False
-                    return False
-            elif self._connected_path != self.csv_path:
-                logger.warning(
-                    "csv_path changed while connected; unwatch all symbols first"
-                )
-
-            self._watched_symbols.update(symbols)
-            formatted = ", ".join(f"{s} ({r.name})" for s, r in symbols)
-            logger.info(f"{self.__class__.__name__} watching {formatted}")
-
-            if not self._streaming_thread or not self._streaming_thread.is_alive():
-                self._stop_event.clear()
-                self._streaming_thread = threading.Thread(
-                    target=self._stream, name="CSVDatafeedStreaming", daemon=False
-                )
-                self._streaming_thread.start()
-
-        return True
-
-    def unwatch(self, symbols: list[str]) -> None:
-        thread_to_join = None
-        with self._lock:
-            symbols_set = set(symbols)
-            self._watched_symbols.difference_update(
-                {
-                    (symbol, rtype)
-                    for (symbol, rtype) in self._watched_symbols
-                    if symbol in symbols_set
-                }
-            )
-            logger.info(f"{self.__class__.__name__} unwatched {', '.join(symbols)}")
-            if not self._watched_symbols:
-                self._stop_event.set()
-                thread_to_join = self._streaming_thread
-                self._streaming_thread = None
-
-        if thread_to_join and thread_to_join.is_alive():
-            thread_to_join.join(timeout=5.0)
-            if thread_to_join.is_alive():
-                logger.warning("Streaming thread did not terminate within timeout")
-            else:
-                logger.info(f"{self.__class__.__name__} disconnected")
-
-    def _stream(self) -> None:
-        if self._data_iterator is None:
-            logger.error("_stream called with no data iterator")
-            return
-        should_delay = self.artificial_delay > 0
-        delay_time = self.artificial_delay
-        while not self._stop_event.is_set():
-            try:
-                chunk = next(self._data_iterator)
-                row = chunk.iloc[0]
-
-                symbol = row["symbol"]
-                record_type = Models.RecordType(row["rtype"])
-                symbol_key = (symbol, record_type)
-
-                with self._lock:
-                    if symbol_key not in self._watched_symbols:
-                        continue
-
-                bar_event = Events.IncomingBar(
-                    ts_event=pd.Timestamp(row["ts_event"], unit="ns", tz="UTC"),
-                    symbol=symbol,
-                    record_type=record_type,
-                    open=row["open"] / 1e9,
-                    high=row["high"] / 1e9,
-                    low=row["low"] / 1e9,
-                    close=row["close"] / 1e9,
-                    volume=row["volume"],
-                )
-
-                event_bus.publish(bar_event)
-
-                if should_delay and self._stop_event.wait(delay_time):
-                    break
-            except StopIteration:
-                logger.info("CSV datafeed reached end of file")
-                break
-            except Exception as e:
-                logger.error(f"CSV datafeed error reading data: {e}")
-                break
-
-        with self._lock:
-            self._data_iterator = None
-            self._is_connected = False
-
-
-simulated_datafeed_csv = SimulatedDatafeedCSV()
-"""
-Global instance of SimulatedDatafeedCSV.
-"""

onesecondtrader-0.21.0/src/onesecondtrader/indicators.py

@@ -1,106 +0,0 @@
-"""
-OneSecondTrader's library of pre-built indicators.
-"""
-
-import abc
-import enum
-import numpy as np
-import threading
-
-from collections import deque
-from onesecondtrader.core import Events
-
-
-class BaseIndicator(abc.ABC):
-    """
-    Base class for indicators. Subclasses must set the `name` property and implement
-    the `_compute_indicator()` method. See `SimpleMovingAverage` for an example.
-    """
-
-    def __init__(self, max_history: int = 100) -> None:
-        self._lock = threading.Lock()
-        self._history: deque[float] = deque(maxlen=max(1, int(max_history)))
-
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        pass
-
-    def update(self, incoming_bar: Events.IncomingBar) -> None:
-        _latest_value: float = self._compute_indicator(incoming_bar)
-        with self._lock:
-            self._history.append(_latest_value)
-
-    @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
-        pass
-
-    @property
-    def latest(self) -> float:
-        with self._lock:
-            return self._history[-1] if self._history else np.nan
-
-    @property
-    def history(self) -> deque[float]:
-        return self._history
-
-
-class InputSource(enum.Enum):
-    """
-    Enum of supported input sources for indicators. Indicators with a `input_source`
-    parameter can be configured to use one of these sources for their calculations.
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    VOLUME = enum.auto()
-
-
-class SimpleMovingAverage(BaseIndicator):
-    """
-    Simple Moving Average (SMA) indicator. Can be configured to use different input
-    sources (see `InputSource` enum, default is `InputSource.CLOSE`).
-    """
-
-    def __init__(
-        self,
-        period: int = 200,
-        max_history: int = 100,
-        input_source: InputSource = InputSource.CLOSE,
-    ) -> None:
-        super().__init__(max_history=max_history)
-        self.period: int = max(1, int(period))
-        self.input_source: InputSource = input_source
-        self._window: deque[float] = deque(maxlen=self.period)
-
-    @property
-    def name(self) -> str:
-        return f"SMA_{self.period}_{self.input_source.name}"
-
-    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
-        value: float = self._extract_input(incoming_bar)
-        self._window.append(value)
-        if len(self._window) < self.period:
-            return np.nan
-        return sum(self._window) / self.period
-
-    def _extract_input(self, incoming_bar: Events.IncomingBar) -> float:
-        match self.input_source:
-            case InputSource.OPEN:
-                return incoming_bar.open
-            case InputSource.HIGH:
-                return incoming_bar.high
-            case InputSource.LOW:
-                return incoming_bar.low
-            case InputSource.CLOSE:
-                return incoming_bar.close
-            case InputSource.VOLUME:
-                return (
-                    float(incoming_bar.volume)
-                    if incoming_bar.volume is not None
-                    else np.nan
-                )
-            case _:
-                return incoming_bar.close