onesecondtrader 0.15.0__py3-none-any.whl → 0.16.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/indicators.py

@@ -0,0 +1,102 @@
+"""
+OneSecondTrader's library of pre-built indicators.
+"""
+
+import abc
+import enum
+import numpy as np
+import threading
+
+from collections import deque
+from onesecondtrader.ontology import Bar
+
+
+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: Bar) -> 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: Bar) -> 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, bar: Bar) -> float:
+        value: float = self._extract_input(bar)
+        self._window.append(value)
+        if len(self._window) < self.period:
+            return np.nan
+        return sum(self._window) / self.period
+
+    def _extract_input(self, bar: Bar) -> float:
+        match self.input_source:
+            case InputSource.OPEN:
+                return float(bar.open)
+            case InputSource.HIGH:
+                return float(bar.high)
+            case InputSource.LOW:
+                return float(bar.low)
+            case InputSource.CLOSE:
+                return float(bar.close)
+            case InputSource.VOLUME:
+                return float(bar.volume)
+            case _:
+                return float(bar.close)

onesecondtrader/ontology.py

@@ -0,0 +1,18 @@
+"""
+Domain-specific data models that are used system-wide.
+"""
+
+import dataclasses
+
+
+@dataclasses.dataclass(slots=True)
+class Bar:
+    """
+    Data model for OHLCV bar data.
+    """
+
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.15.0
+Version: 0.16.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.16.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/indicators.py,sha256=nV7EFlOnNWxdU6-lb4rxvzjfdRIXkS7P-tyH08cSrKM,2967
+onesecondtrader/ontology.py,sha256=z1fipmt6Rh8nS1Z-M3ln197TWPWSvt6rkBQXkdXhekM,263
+onesecondtrader-0.16.0.dist-info/METADATA,sha256=oU16PF9yR3neuhhQNZbE64ZcSdBAnr4j1-_wecDwDkQ,9682
+onesecondtrader-0.16.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+onesecondtrader-0.16.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.16.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()

onesecondtrader/core/portfolio.py

@@ -1,177 +0,0 @@
-import threading
-
-from onesecondtrader import messaging
-from onesecondtrader.messaging import events
-from onesecondtrader.strategies import base_strategy
-from onesecondtrader.monitoring import console
-from onesecondtrader.core import models
-
-
-class Portfolio:
-    def __init__(self, event_bus: messaging.EventBus | None = None):
-        """
-        Initialize the Portfolio class and subscribe to events.
-        Most importantly, the `symbol_to_strategy` registry is initialized,
-         which keeps track of which symbols are currently assigned to which strategy
-         in order to enforce exclusive symbol ownership.
-
-        Args:
-            event_bus (messaging.EventBus | None): Event bus to use; defaults to
-                 messaging.system_event_bus when None.
-
-        Attributes:
-            self._lock (threading.Lock): Lock for thread-safe operations.
-            self.event_bus (messaging.EventBus): Event bus used for communication
-                 between the trading infrastructure's components.
-            self.symbols_to_strategy (dict[str, base_strategy.Strategy]): Registry of
-                 symbols to strategies.
-        """
-        # ------------------------------------------------------------------------------
-        # INITIALIZE LOCK FOR THREAD-SAFE OPERATIONS
-        self._lock: threading.Lock = threading.Lock()
-
-        # ------------------------------------------------------------------------------
-        # INITIALIZE EVENT BUS AND SUBSCRIBE TO EVENTS
-        self.event_bus: messaging.EventBus = (
-            event_bus if event_bus else messaging.system_event_bus
-        )
-        self.event_bus.subscribe(events.Strategy.SymbolRelease, self.on_symbol_release)
-
-        # ------------------------------------------------------------------------------
-        # INITIALIZE SYMBOLS TO STRATEGY REGISTRY
-        self.symbols_to_strategy: dict[str, base_strategy.Strategy] = {}
-
-    def on_symbol_release(self, event: messaging.events.Base.Event) -> None:
-        """
-        Event handler for symbol release events (`events.Strategy.SymbolRelease`).
-        The symbol is removed from the `symbols_to_strategy` registry.
-
-        Args:
-            event (messaging.events.Base.Event): Symbol release event.
-        """
-        # ------------------------------------------------------------------------------
-        # IGNORE UNRELATED EVENT TYPES
-        if not isinstance(event, events.Strategy.SymbolRelease):
-            return
-
-        # ------------------------------------------------------------------------------
-        # RELEASE SYMBOL FROM STRATEGY
-        symbol = event.symbol
-        with self._lock:
-            if symbol in self.symbols_to_strategy:
-                del self.symbols_to_strategy[symbol]
-                console.logger.info(
-                    f"on_symbol_release: symbol {symbol} released from "
-                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
-                )
-            else:
-                console.logger.warning(
-                    f"on_symbol_release: symbol {symbol} not owned by "
-                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
-                )
-
-    def assign_symbols(
-        self, strategy_instance: base_strategy.Strategy, symbols: list[str]
-    ) -> bool:
-        """
-        Assign a list of symbols to a strategy if no conflicts exist and notify the
-         strategy of the assignment.
-
-        Args:
-            strategy_instance (base_strategy.Strategy): Strategy instance to assign
-                symbols to.
-            symbols (list[str]): List of symbols to assign.
-        """
-        # ------------------------------------------------------------------------------
-        # VALIDATE THAT INSTANCE IS A SUBCLASS OF base_strategy.Strategy
-        if not isinstance(strategy_instance, base_strategy.Strategy):
-            console.logger.error("assign_symbols: strategy must inherit from Strategy")
-            return False
-
-        # ------------------------------------------------------------------------------
-        # CHECK FOR CONFLICTS
-        non_conflicting: list[str] = []
-        conflicting: list[str] = []
-        with self._lock:
-            for symbol in symbols:
-                owner = self.symbols_to_strategy.get(symbol)
-                if owner is None:
-                    non_conflicting.append(symbol)
-                else:
-                    conflicting.append(symbol)
-        if conflicting:
-            console.logger.warning(
-                "assign_symbols: symbols not assigned due to conflicts; "
-                "use Portfolio.assign_symbols(...) after resolving. "
-                f"non_conflicting={non_conflicting}, conflicts={conflicting}"
-            )
-            return False
-        else:
-            # --------------------------------------------------------------------------
-            # ASSIGN SYMBOLS TO REGISTRY
-            for symbol in symbols:
-                self.symbols_to_strategy[symbol] = strategy_instance
-
-            # --------------------------------------------------------------------------
-            # PUBLISH SYMBOL ASSIGNMENT EVENT
-            # noinspection PyArgumentList
-            self.event_bus.publish(
-                events.Strategy.SymbolAssignment(
-                    strategy=strategy_instance,
-                    symbol_list=symbols,
-                )
-            )
-            return True
-
-    def unassign_symbols(
-        self,
-        symbols: list[str],
-        shutdown_mode: models.SymbolShutdownMode = models.SymbolShutdownMode.SOFT,
-    ) -> bool:
-        """
-        Unassign a list of symbols from their owning strategy if all of them have
-         previously been assigned to a strategy.
-        Calling this methods will request the owning strategy to stop trading the symbol
-         in the manner dictated via the `shutdown_mode` argument (default to soft
-         shutdown, i.e. wait for open positions to close naturally and release symbols
-         once they are flat).
-        After the owning strategy has released the symbol, the symbol is unassigned from
-         the portfolio via the `on_symbol_release` event handler.
-
-        Args:
-            symbols (list[str]): List of symbols to unassign.
-            shutdown_mode (models.SymbolShutdownMode): Shutdown mode to use. Defaults
-                to `models.SymbolShutdownMode.SOFT`.
-        """
-        # ------------------------------------------------------------------------------
-        # CHECK THAT SYMBOLS ARE REGISTERED
-        conflicting: list[str] = []
-        with self._lock:
-            for symbol in symbols:
-                if symbol not in self.symbols_to_strategy:
-                    conflicting.append(symbol)
-            if conflicting:
-                console.logger.warning(
-                    "unassign_symbols: symbols not unassigned due to conflicts; "
-                    f"conflicts={conflicting}. "
-                    f"Use Portfolio.unassign_symbols(...) after resolving."
-                )
-                return False
-            else:
-                # ----------------------------------------------------------------------
-                # PUBLISH STOP TRADING SYMBOL EVENT FOR EACH SYMBOL
-                for symbol in symbols:
-                    # noinspection PyArgumentList
-                    self.event_bus.publish(
-                        events.Strategy.StopTradingSymbol(
-                            strategy=self.symbols_to_strategy[symbol],
-                            symbol=symbol,
-                            shutdown_mode=shutdown_mode,
-                        )
-                    )
-                    console.logger.info(
-                        f"unassign_symbols: trading stop for {symbol} trading strategy "
-                        f"{self.symbols_to_strategy[symbol]} requested with shutdown"
-                        f"mode {shutdown_mode.name}"
-                    )
-                return True