onesecondtrader 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

onesecondtrader/__init__.py

@@ -1,12 +0,0 @@
-"""
-The Trading Infrastructure Toolkit for Python.
-
-Research, simulate, and deploy algorithmic trading strategies — all in one place.
-"""
-
-from .monitoring.console import logger
-
-
-__all__ = [
-    "logger",
-]

onesecondtrader/core.py

@@ -0,0 +1,105 @@
+"""
+Core module containing the backbone of OneSecondTrader's event-driven architecture.
+"""
+
+import abc
+import dataclasses
+import enum
+import pandas as pd
+import queue
+import threading
+
+from collections import defaultdict
+
+
+class Models:
+    """
+    Namespace for all models.
+    """
+
+    class RecordType(enum.Enum):
+        OHLCV_1S = 32
+        OHLCV_1M = 33
+        OHLCV_1H = 34
+        OHLCV_1D = 35
+
+
+class Events:
+    """
+    Namespace for all events.
+    """
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class BaseEvent:
+        ts_event: pd.Timestamp = dataclasses.field(
+            default_factory=lambda: pd.Timestamp.now(tz="UTC")
+        )
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class SystemShutdown(BaseEvent):
+        pass
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class IncomingBar(BaseEvent):
+        ts_event: pd.Timestamp
+        symbol: str
+        record_type: Models.RecordType
+        open: float
+        high: float
+        low: float
+        close: float
+        volume: int | None = None
+
+
+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, 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)

onesecondtrader/indicators.py

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

{onesecondtrader-0.15.0.dist-info → onesecondtrader-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.15.0
+Version: 0.17.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
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: matplotlib (>=3.10.7,<4.0.0)
 Requires-Dist: pandas (>=2.3.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown

onesecondtrader-0.17.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/core.py,sha256=_ww01j3PQ0bCRkkTDxDD-cNtD4dkeaIFKwBn2ro0Y5M,2766
+onesecondtrader/indicators.py,sha256=wGn-5v8L1gepMP45KcVrEo-f2ReOCD3r8lva9aEIUnY,3199
+onesecondtrader-0.17.0.dist-info/METADATA,sha256=Y-rLsvsHp0Vo-6lG0FqXE0Abm6YxaduSWkNb5D0Zv7g,9682
+onesecondtrader-0.17.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+onesecondtrader-0.17.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.17.0.dist-info/RECORD,,

onesecondtrader/brokers/base_broker.py

@@ -1,99 +0,0 @@
-import abc
-from onesecondtrader import messaging
-from onesecondtrader.messaging import events
-
-
-class BaseBroker(abc.ABC):
-    def __init__(self, event_bus: messaging.EventBus | None = None):
-        self.event_bus: messaging.EventBus = (
-            event_bus if event_bus else messaging.system_event_bus
-        )
-        self._is_connected: bool = False
-
-    def connect(self) -> bool:
-        if self._is_connected:
-            return True
-        self._subscribe_to_events()
-        self._is_connected = True
-        return True
-
-    def disconnect(self) -> None:
-        if not self._is_connected:
-            return
-        try:
-            self.event_bus.unsubscribe(events.System.Shutdown, self.on_system_shutdown)
-        finally:
-            self._is_connected = False
-
-    @property
-    def is_connected(self) -> bool:
-        return self._is_connected
-
-    def _subscribe_to_events(self) -> None:
-        """
-        Subscribe to relevant events from the event bus.
-        """
-        self.event_bus.subscribe(events.System.Shutdown, self.on_system_shutdown)
-        self.event_bus.subscribe(events.Strategy.SymbolRelease, self.on_symbol_release)
-
-    def on_system_shutdown(self, event: events.Base.Event) -> None:
-        """
-        Handle system shutdown events (ignore unrelated events).
-        """
-        if not isinstance(event, events.System.Shutdown):
-            return
-        # Default no-op
-        return
-
-    def on_symbol_release(self, event: events.Base.Event) -> None:
-        """
-        Handle portfolio symbol release events (ignore unrelated events).
-        Intended for brokers to perform any symbol-specific cleanup if necessary.
-        Default implementation is a no-op.
-        """
-        if not isinstance(event, events.Strategy.SymbolRelease):
-            return
-        # Default no-op
-        return
-
-    def on_request_market_order(self, event: events.Request.MarketOrder) -> None:
-        """
-        Handle market order requests.
-        """
-        pass
-
-    def on_request_limit_order(self, event: events.Request.LimitOrder) -> None:
-        """
-        Handle limit order requests.
-        """
-        pass
-
-    def on_request_stop_order(self, event: events.Request.StopOrder) -> None:
-        """
-        Handle stop order requests.
-        """
-        pass
-
-    def on_request_stop_limit_order(self, event: events.Request.StopLimitOrder) -> None:
-        """
-        Handle stop limit order requests.
-        """
-        pass
-
-    def on_request_cancel_order(self, event: events.Request.CancelOrder) -> None:
-        """
-        Handle cancel order requests.
-        """
-        pass
-
-    def on_request_flush_symbol(self, event: events.Request.FlushSymbol) -> None:
-        """
-        Handle flush symbol requests.
-        """
-        pass
-
-    def on_request_flush_all(self, event: events.Request.FlushAll) -> None:
-        """
-        Handle flush all requests.
-        """
-        pass

onesecondtrader/brokers/simulated_broker.py

@@ -1,10 +0,0 @@
-from onesecondtrader.brokers import base_broker
-
-
-class SimulatedBroker(base_broker.BaseBroker):
-    """
-    Simple simulated broker used as a safe default.
-    """
-
-    def __init__(self, event_bus=None):
-        super().__init__(event_bus)

onesecondtrader/core/models.py

@@ -1,204 +0,0 @@
-from dataclasses import dataclass
-import enum
-
-
-@dataclass(frozen=True, slots=True)
-class Bar:
-    """
-    Class for representing a OHLC(V) bar of market data.
-
-    Attributes:
-        open (float): Open price
-        high (float): High price
-        low (float): Low price
-        close (float): Close price
-        volume (int | None): Volume
-    """
-
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-
-
-class Side(enum.Enum):
-    """
-    Enum for order sides.
-    """
-
-    BUY = enum.auto()
-    SELL = enum.auto()
-
-
-class TimeInForce(enum.Enum):
-    """
-    Order time-in-force specifications.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `DAY` | `enum.auto()` | Valid until end of trading day |
-    | `FOK` | `enum.auto()` | Fill entire order immediately or cancel (Fill-or-Kill) |
-    | `GTC` | `enum.auto()` | Active until explicitly cancelled (Good-Till-Cancelled) |
-    | `GTD` | `enum.auto()` | Active until specified date (Good-Till-Date) |
-    | `IOC` | `enum.auto()` | Execute available quantity immediately, cancel rest (Immediate-or-Cancel) |
-    """
-
-    DAY = enum.auto()
-    FOK = enum.auto()
-    GTC = enum.auto()
-    GTD = enum.auto()
-    IOC = enum.auto()
-
-
-class OrderType(enum.Enum):
-    """
-    Enum for order types.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `MARKET` | `enum.auto()` | Market order |
-    | `LIMIT` | `enum.auto()` | Limit order |
-    | `STOP` | `enum.auto()` | Stop order |
-    | `STOP_LIMIT` | `enum.auto()` | Stop-limit order |
-    """
-
-    MARKET = enum.auto()
-    LIMIT = enum.auto()
-    STOP = enum.auto()
-    STOP_LIMIT = enum.auto()
-
-
-class OrderLifecycleState(enum.Enum):
-    """
-    Enum for order lifecycle states.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `PENDING` | `enum.auto()` | Order has been submitted, but not yet acknowledged by the brokers |
-    | `OPEN` | `enum.auto()` | Order has been acknowledged by the brokers, but not yet filled or cancelled |
-    | `FILLED` | `enum.auto()` | Order has been filled |
-    | `CANCELLED` | `enum.auto()` | Order has been cancelled |
-    """
-
-    PENDING = enum.auto()
-    OPEN = enum.auto()
-    PARTIALLY_FILLED = enum.auto()
-    FILLED = enum.auto()
-    CANCELLED = enum.auto()
-
-
-class OrderRejectionReason(enum.Enum):
-    """
-    Enum for order rejection reasons.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `UNKNOWN` | `enum.auto()` | Unknown reason |
-    | `NEGATIVE_QUANTITY` | `enum.auto()` | Negative quantity |
-    """
-
-    UNKNOWN = enum.auto()
-    NEGATIVE_QUANTITY = enum.auto()
-
-
-class RecordType(enum.Enum):
-    """
-    Enum for Databento record types.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `OHLCV_1S` | `32` | 1-second bars |
-    | `OHLCV_1M` | `33` | 1-minute bars |
-    | `OHLCV_1H` | `34` | 1-hour bars |
-    | `OHLCV_1D` | `35` | 1-day bars |
-    """
-
-    OHLCV_1S = 32
-    OHLCV_1M = 33
-    OHLCV_1H = 34
-    OHLCV_1D = 35
-
-    @classmethod
-    def to_string(cls, rtype: int) -> str:
-        match rtype:
-            case cls.OHLCV_1S.value:
-                return "1-second bars"
-            case cls.OHLCV_1M.value:
-                return "1-minute bars"
-            case cls.OHLCV_1H.value:
-                return "1-hour bars"
-            case cls.OHLCV_1D.value:
-                return "daily bars"
-            case _:
-                return f"unknown ({rtype})"
-
-
-class XMAMode(enum.Enum):
-    """
-    Enum for moving average modes.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `OPEN` | `enum.auto()` | Open price |
-    | `HIGH` | `enum.auto()` | High price |
-    | `LOW` | `enum.auto()` | Low price |
-    | `CLOSE` | `enum.auto()` | Close price |
-    | `TYPICAL_PRICE` | `enum.auto()` | Typical price ((H+ L + C) / 3) |
-    | `WEIGHTED_CLOSE` | `enum.auto()` | Weighted close price ((H + L + 2*C) / 4) |
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    TYPICAL_PRICE = enum.auto()
-    WEIGHTED_CLOSE = enum.auto()
-
-
-class Position:
-    pass
-
-
-class StrategyShutdownMode(enum.Enum):
-    """
-    Enum for strategy shutdown modes.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `SOFT` | `enum.auto()` | Do not open new positions; wait until current positions close naturally |
-    | `HARD` | `enum.auto()` | Close all positions immediately with market orders |
-    """
-
-    SOFT = enum.auto()
-    HARD = enum.auto()
-
-
-class SymbolShutdownMode(enum.Enum):
-    """
-    Enum for symbol shutdown modes.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `SOFT` | `enum.auto()` | Do not open new positions; wait until current positions close naturally |
-    | `HARD` | `enum.auto()` | Close all positions immediately with market orders |
-    """
-
-    SOFT = enum.auto()
-    HARD = enum.auto()