onesecondtrader 0.47.0__tar.gz → 0.49.0__tar.gz

{onesecondtrader-0.47.0 → onesecondtrader-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.47.0
+Version: 0.49.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.47.0 → onesecondtrader-0.49.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.47.0"
+version = "0.49.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.49.0/src/onesecondtrader/events/__init__.py

@@ -0,0 +1,8 @@
+"""
+Defines the event message objects propagated through the system.
+"""
+
+from .base import EventBase
+from . import market, orders, requests, responses
+
+__all__ = ["EventBase", "market", "orders", "requests", "responses"]

onesecondtrader-0.49.0/src/onesecondtrader/indicators/__init__.py

@@ -0,0 +1,17 @@
+"""
+Provides a library of common technical indicators and a base class for creating custom ones.
+"""
+
+from .base import IndicatorBase
+from .moving_averages import SimpleMovingAverage
+from .market_fields import Open, High, Low, Close, Volume
+
+__all__ = [
+    "IndicatorBase",
+    "SimpleMovingAverage",
+    "Open",
+    "High",
+    "Low",
+    "Close",
+    "Volume",
+]

onesecondtrader-0.49.0/src/onesecondtrader/indicators/base.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import abc
+import collections
+import threading
+
+import numpy as np
+
+from onesecondtrader import events
+
+
+class IndicatorBase(abc.ABC):
+    """
+    Base class for scalar technical indicators with per-symbol history.
+
+    The class provides a thread-safe mechanism for storing and retrieving indicator values computed from incoming market bars, keyed by symbol.
+    It does not manage input windows or rolling computation state.
+
+    Subclasses define a stable indicator identifier via the `name` property and implement `_compute_indicator`, which computes a single scalar value per incoming bar.
+    Indicators with multiple conceptual outputs must be implemented as multiple single-output indicators (e.g. Bollinger Bands must be implemented via three separate indicators `BBUpper`, `BBMiddle`, and `BBLower`).
+
+    The update mechanism is thread-safe.
+    Indicator computation is performed outside the internal lock.
+    Subclasses that maintain internal state are responsible for ensuring its thread safety and must not access `_history_data`.
+
+    Indicator values are stored per symbol in bounded FIFO buffers.
+    Missing data and out-of-bounds access yield `numpy.nan`.
+
+    The `plot_at` attribute is an opaque identifier forwarded to the charting backend and has no intrinsic meaning within the indicator subsystem.
+    """
+
+    def __init__(self, max_history: int = 100, plot_at: int = 99) -> None:
+        """
+        Parameters:
+            max_history:
+                Maximum number of indicator values retained per symbol.
+                Cannot be less than 1.
+            plot_at:
+                Opaque plotting identifier forwarded to the charting backend.
+        """
+        self._lock = threading.Lock()
+        self._max_history = max(1, int(max_history))
+        self._history_data: dict[str, collections.deque[float]] = {}
+        self._plot_at = plot_at
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Stable identifier used for charting and downstream integration.
+        """
+        pass
+
+    @abc.abstractmethod
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Compute the indicator value for a single market bar.
+
+        This method is executed outside the internal lock.
+        Implementations must not access `_history_data` and must ensure thread safety of any internal computation state.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input for indicator computation.
+
+        Returns:
+            Computed indicator value.
+        """
+        pass
+
+    def update(self, incoming_bar: events.market.BarReceived) -> None:
+        """
+        Update the indicator with a new market bar.
+
+        The computed value is appended to the per-symbol history buffer.
+
+        Parameters:
+            incoming_bar:
+                Market bar triggering the update.
+        """
+        symbol = incoming_bar.symbol
+
+        value = self._compute_indicator(incoming_bar)
+
+        with self._lock:
+            if symbol not in self._history_data:
+                self._history_data[symbol] = collections.deque(maxlen=self._max_history)
+
+            self._history_data[symbol].append(value)
+
+    def latest(self, symbol: str) -> float:
+        """
+        Return the most recent indicator value for a symbol.
+
+        Parameters:
+            symbol:
+                Symbol identifier.
+
+        Returns:
+            Most recent value, or `numpy.nan` if unavailable.
+        """
+        return self[symbol, -1]
+
+    def __getitem__(self, key: tuple[str, int]) -> float:
+        """
+        Retrieve an indicator value by symbol and index.
+
+        Indexing follows standard Python sequence semantics.
+        Negative indices refer to positions relative to the most recent value.
+
+        Parameters:
+            key:
+                `(symbol, index)` pair specifying the symbol and history offset.
+
+        Returns:
+            Indicator value at the specified position, or `numpy.nan` if unavailable.
+        """
+        symbol, index = key
+
+        with self._lock:
+            history = self._history_data.get(symbol)
+
+            if history is None:
+                return np.nan
+
+            try:
+                return history[index]
+            except IndexError:
+                return np.nan
+
+    @property
+    def plot_at(self) -> int:
+        """
+        Plotting identifier.
+
+        Returns:
+            Opaque identifier consumed by the charting backend.
+        """
+        return self._plot_at

onesecondtrader-0.49.0/src/onesecondtrader/indicators/market_fields.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import numpy as np
+
+from onesecondtrader import events, indicators
+
+
+class Open(indicators.IndicatorBase):
+    """
+    Open price indicator.
+
+    This indicator exposes the open price of each incoming market bar as a scalar time series.
+    Values are stored per symbol and can be accessed historically via the indicator interface.
+    """
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Fixed identifier for the open price indicator.
+        """
+        return "OPEN"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the open price from an incoming market bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input.
+
+        Returns:
+            Open price of the bar.
+        """
+        return incoming_bar.open
+
+
+class High(indicators.IndicatorBase):
+    """
+    High price indicator.
+
+    This indicator exposes the high price of each incoming market bar as a scalar time series.
+    Values are stored per symbol and can be accessed historically via the indicator interface.
+    """
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Fixed identifier for the high price indicator.
+        """
+        return "HIGH"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the high price from an incoming market bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input.
+
+        Returns:
+            High price of the bar.
+        """
+        return incoming_bar.high
+
+
+class Low(indicators.IndicatorBase):
+    """
+    Low price indicator.
+
+    This indicator exposes the low price of each incoming market bar as a scalar time series.
+    Values are stored per symbol and can be accessed historically via the indicator interface.
+    """
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Fixed identifier for the low price indicator.
+        """
+        return "LOW"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the low price from an incoming market bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input.
+
+        Returns:
+            Low price of the bar.
+        """
+        return incoming_bar.low
+
+
+class Close(indicators.IndicatorBase):
+    """
+    Close price indicator.
+
+    This indicator exposes the close price of each incoming market bar as a scalar time series.
+    Values are stored per symbol and can be accessed historically via the indicator interface.
+    """
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Fixed identifier for the close price indicator.
+        """
+        return "CLOSE"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the close price from an incoming market bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input.
+
+        Returns:
+            Close price of the bar.
+        """
+        return incoming_bar.close
+
+
+class Volume(indicators.IndicatorBase):
+    """
+    Volume indicator.
+
+    This indicator exposes the traded volume of each incoming market bar as a scalar time series.
+    Values are stored per symbol and can be accessed historically via the indicator interface.
+    Missing volume values yield `numpy.nan`.
+    """
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Fixed identifier for the volume indicator.
+        """
+        return "VOLUME"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the volume from an incoming market bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input.
+
+        Returns:
+            Volume of the bar, or `numpy.nan` if unavailable.
+        """
+        return float(incoming_bar.volume) if incoming_bar.volume is not None else np.nan

onesecondtrader-0.49.0/src/onesecondtrader/indicators/moving_averages.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import collections
+import numpy as np
+
+from onesecondtrader import events, indicators, models
+
+
+class SimpleMovingAverage(indicators.IndicatorBase):
+    """
+    Simple Moving Average (SMA) indicator.
+
+    This indicator computes the arithmetic mean of a selected bar field over a fixed rolling window.
+    One scalar value is produced per incoming bar and stored per symbol.
+
+    The rolling window is maintained independently for each symbol.
+    Until the window is fully populated, the indicator yields `numpy.nan`.
+    """
+
+    def __init__(
+        self,
+        period: int = 200,
+        max_history: int = 100,
+        bar_field: models.BarField = models.BarField.CLOSE,
+        plot_at: int = 0,
+    ) -> None:
+        """
+        Parameters:
+            period:
+                Window size used to compute the moving average.
+            max_history:
+                Maximum number of computed indicator values retained per symbol.
+            bar_field:
+                Bar field used as the input series.
+            plot_at:
+                Opaque plotting identifier forwarded to the charting backend.
+        """
+        super().__init__(max_history=max_history, plot_at=plot_at)
+
+        self.period: int = max(1, int(period))
+        self.bar_field: models.BarField = bar_field
+        self._window: dict[str, collections.deque[float]] = {}
+
+    @property
+    def name(self) -> str:
+        """
+        Canonical indicator name.
+
+        Returns:
+            Identifier encoding the indicator type, period, and bar field.
+        """
+        return f"SMA_{self.period}_{self.bar_field.name}"
+
+    def _compute_indicator(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Compute the simple moving average for a single received bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar used as input for the computation.
+
+        Returns:
+            Simple moving average value, or `numpy.nan` if the rolling window is not yet fully populated.
+        """
+        symbol = incoming_bar.symbol
+        if symbol not in self._window:
+            self._window[symbol] = collections.deque(maxlen=self.period)
+
+        window = self._window[symbol]
+        value = self._extract_field(incoming_bar)
+        window.append(value)
+
+        if len(window) < self.period:
+            return np.nan
+        return sum(window) / self.period
+
+    def _extract_field(self, incoming_bar: events.market.BarReceived) -> float:
+        """
+        Extract the configured bar field from an incoming bar.
+
+        Parameters:
+            incoming_bar:
+                Market bar providing the input data.
+
+        Returns:
+            Extracted field value, or `numpy.nan` if unavailable.
+        """
+        match self.bar_field:
+            case models.BarField.OPEN:
+                return incoming_bar.open
+            case models.BarField.HIGH:
+                return incoming_bar.high
+            case models.BarField.LOW:
+                return incoming_bar.low
+            case models.BarField.CLOSE:
+                return incoming_bar.close
+            case models.BarField.VOLUME:
+                return (
+                    float(incoming_bar.volume)
+                    if incoming_bar.volume is not None
+                    else np.nan
+                )
+            case _:
+                return incoming_bar.close

onesecondtrader-0.47.0/src/onesecondtrader/events/__init__.py

@@ -1,7 +0,0 @@
-"""
-Defines the event message objects propagated through the system.
-"""
-
-from .base import EventBase
-
-__all__ = ["EventBase"]