onesecondtrader 0.22.0__tar.gz → 0.24.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.22.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.22.0 → onesecondtrader-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.22.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.22.0/src/onesecondtrader/brokers.py

@@ -1,92 +0,0 @@
-import abc
-import uuid
-
-from onesecondtrader.core import BaseConsumer, Events, event_bus
-
-
-class BaseBroker(BaseConsumer):
-    """
-    Base class for all brokers.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        event_bus.subscribe(self, Events.SubmitOrder)
-        event_bus.subscribe(self, Events.CancelOrder)
-        event_bus.subscribe(self, Events.ModifyOrder)
-
-    def on_event(self, event) -> None:
-        match event:
-            case Events.SubmitOrder():
-                self.on_submit_order(event)
-            case Events.CancelOrder():
-                self.on_cancel_order(event)
-            case Events.ModifyOrder():
-                self.on_modify_order(event)
-
-    @abc.abstractmethod
-    def on_submit_order(self, event: Events.SubmitOrder) -> None:
-        pass
-
-    @abc.abstractmethod
-    def on_cancel_order(self, event: Events.CancelOrder) -> None:
-        pass
-
-    @abc.abstractmethod
-    def on_modify_order(self, event: Events.ModifyOrder) -> None:
-        pass
-
-
-class SimulatedBroker(BaseBroker):
-    """
-    Simulated broker for backtesting.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        event_bus.subscribe(self, Events.IncomingBar)
-
-        self._pending_market_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_limit_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_stop_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_stop_limit_orders: dict[
-            str, dict[uuid.UUID, Events.SubmitOrder]
-        ] = {}
-
-    def on_event(self, event) -> None:
-        match event:
-            case Events.SubmitOrder():
-                self.on_submit_order(event)
-            case Events.CancelOrder():
-                self.on_cancel_order(event)
-            case Events.ModifyOrder():
-                self.on_modify_order(event)
-            case Events.IncomingBar():
-                self.on_incoming_bar(event)
-
-    def on_submit_order(self, event: Events.SubmitOrder) -> None:
-        pass
-
-    def on_cancel_order(self, event: Events.CancelOrder) -> None:
-        pass
-
-    def on_modify_order(self, event: Events.ModifyOrder) -> None:
-        pass
-
-    def on_incoming_bar(self, event: Events.IncomingBar) -> None:
-        self._process_pending_orders(event)
-
-        bar_ready = Events.BarReady(
-            ts_event=event.ts_event,
-            symbol=event.symbol,
-            record_type=event.record_type,
-            open=event.open,
-            high=event.high,
-            low=event.low,
-            close=event.close,
-            volume=event.volume,
-        )
-        event_bus.publish(bar_ready)
-
-    def _process_pending_orders(self, event: Events.IncomingBar) -> None:
-        pass

onesecondtrader-0.22.0/src/onesecondtrader/core.py

@@ -1,260 +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
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class BarReady(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):
-        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 CancelOrder(BrokerRequestEvent):
-        symbol: str
-        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):
-                self.queue.task_done()
-                break
-            self.on_event(event)
-            self.queue.task_done()
-
-
-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._consumers: set[BaseConsumer] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(self, subscriber: BaseConsumer, event_type: type[Events.BaseEvent]):
-        with self._lock:
-            self._consumers.add(subscriber)
-            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)
-            if not any(subscriber in cl for cl in self._subscriptions.values()):
-                self._consumers.discard(subscriber)
-
-    def publish(self, event: Events.BaseEvent) -> None:
-        with self._lock:
-            consumers = list(self._subscriptions[type(event)])
-        for consumer in consumers:
-            consumer.receive(event)
-
-    # Enable synchronous execution via wait_until_idle()
-    def wait_until_idle(self) -> None:
-        with self._lock:
-            consumers = list(self._consumers)
-        for consumer in consumers:
-            consumer.queue.join()
-
-
-event_bus = EventBus()
-"""
-Global instance of `EventBus`.
-"""

onesecondtrader-0.22.0/src/onesecondtrader/datafeeds.py

@@ -1,173 +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)
-                event_bus.wait_until_idle()
-
-                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.22.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