onesecondtrader 0.12.0__tar.gz → 0.13.0__tar.gz

{onesecondtrader-0.12.0 → onesecondtrader-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.12.0
+Version: 0.13.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.12.0 → onesecondtrader-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.12.0"
+version = "0.13.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.12.0 → onesecondtrader-0.13.0}/src/onesecondtrader/core/models.py

@@ -63,8 +63,7 @@ class TimeInForce(enum.Enum):
     | `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) |
+    | `IOC` | `enum.auto()` | Execute available quantity immediately, cancel rest (Immediate-or-Cancel) |
     """
 
     DAY = enum.auto()
@@ -102,10 +101,8 @@ class OrderLifecycleState(enum.Enum):
 
     | Enum | Value | Description |
     |------|-------|-------------|
-    | `PENDING` | `enum.auto()` | Order has been submitted, but not yet acknowledged by
-        the broker |
-    | `OPEN` | `enum.auto()` | Order has been acknowledged by the broker, but not yet
-        filled or cancelled |
+    | `PENDING` | `enum.auto()` | Order has been submitted, but not yet acknowledged by the broker |
+    | `OPEN` | `enum.auto()` | Order has been acknowledged by the broker, but not yet filled or cancelled |
     | `FILLED` | `enum.auto()` | Order has been filled |
     | `CANCELLED` | `enum.auto()` | Order has been cancelled |
     """
@@ -165,3 +162,27 @@ class RecordType(enum.Enum):
                 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()

{onesecondtrader-0.12.0 → onesecondtrader-0.13.0}/src/onesecondtrader/indicators/base_indicator.py

@@ -16,8 +16,7 @@ class BaseIndicator(abc.ABC):
     Base class for all indicators.
 
     If new market data is received, the indicator is updated by calling the
-    `<indicator_instance>.update(incoming_bar)` method.
-
+    `update(incoming_bar)` method.
     When programming a new indicator, only the `name` property and the
     `_compute_indicator()` method need to be implemented.
 
@@ -84,6 +83,15 @@ class BaseIndicator(abc.ABC):
         """
         pass
 
+    @property
+    def latest(self) -> float:
+        """
+        The latest (most recent) indicator value.
+
+        Equivalent to self[0]. Returns numpy.nan when no value is available yet.
+        """
+        return self[0]
+
     def update(self, incoming_bar: models.Bar) -> None:
         """
         Updates the indicator based on an incoming closed bar by calling
@@ -93,6 +101,14 @@ class BaseIndicator(abc.ABC):
         with self._lock:
             self._history.append(new_value)
 
+    @abc.abstractmethod
+    def _compute_indicator(self, incoming_bar: models.Bar) -> float:
+        """
+        Computes the new indicator value based on an incoming closed bar.
+        This method must be implemented by subclasses.
+        """
+        pass
+
     def __getitem__(self, index: int) -> float:
         """
         Return the indicator value at the given index with tolerant indexing.
@@ -118,20 +134,3 @@ class BaseIndicator(abc.ABC):
                 return self._history[normalized]
             except IndexError:
                 return np.nan
-
-    @property
-    def latest(self) -> float:
-        """
-        The latest (most recent) indicator value.
-
-        Equivalent to self[0]. Returns numpy.nan when no value is available yet.
-        """
-        return self[0]
-
-    @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: models.Bar) -> float:
-        """
-        Computes the new indicator value based on an incoming closed bar.
-        This method must be implemented by subclasses.
-        """
-        pass

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

@@ -0,0 +1,132 @@
+"""
+This module provides various moving average indicators.
+"""
+
+import numpy as np
+import collections
+from onesecondtrader.indicators import base_indicator
+from onesecondtrader.core import models
+from onesecondtrader.monitoring import console
+
+
+class SimpleMovingAverage(base_indicator.BaseIndicator):
+    """
+    Simple Moving Average (SMA) indicator for different OHLC-data related time series,
+     the possible modes for the SMA calculation are indicated in the
+     `core.models.XMAMode` enum (currently: `open`, `high`, `low`, `close`,
+     `typical_price`, `weighted close`).
+
+    Examples:
+        >>> from onesecondtrader.indicators import moving_averages
+        >>> from onesecondtrader.core import models
+        >>> sma = moving_averages.SimpleMovingAverage(
+        ...     period=3, mode=models.XMAMode.CLOSE
+        ... )
+        >>> bar1 = models.Bar(
+        ...     open=100.0, high=101.0, low=99.0, close=100.0, volume=1000
+        ... )
+        >>> sma.update(bar1)
+        >>> import numpy as np
+        >>> np.isnan(sma.latest)
+        True
+        >>> bar2 = models.Bar(
+        ...     open=100.0, high=102.0, low=100.0, close=101.0, volume=1500
+        ... )
+        >>> sma.update(bar2)
+        >>> np.isnan(sma.latest)
+        True
+        >>> bar3 = models.Bar(
+        ...     open=101.0, high=103.0, low=101.0, close=102.0, volume=2000
+        ... )
+        >>> sma.update(bar3)
+        >>> np.isnan(sma.latest)
+        False
+        >>> sma.latest
+        101.0
+    """
+
+    def __init__(
+        self,
+        period: int,
+        mode: models.XMAMode = models.XMAMode.CLOSE,
+        max_history: int = 100,
+    ) -> None:
+        """
+        Initialize the indicator with a period and a mode.
+
+        Args:
+            period (int): Period of the moving average. Will be set to 1 if < 1.
+            mode (models.XMAMode): Mode of the moving average. Defaults to `CLOSE`.
+            max_history (int): Maximum lookback history length. Defaults to 100.
+
+        Attributes:
+            self.period (int): Period of the moving average.
+            self.mode (models.XMAMode): Mode of the moving average.
+        """
+        if period < 1:
+            console.logger.warning(
+                f"Period must be >= 1, got {period}; defaulting to 1"
+            )
+            period = 1
+
+        super().__init__(max_history=max_history)
+        self.period: int = period
+        self.mode: models.XMAMode = mode
+        self._window: collections.deque[float] = collections.deque(maxlen=self.period)
+
+    @property
+    def name(self) -> str:
+        return f"SMA_{self.period}_{self.mode.name}"
+
+    def _compute_indicator(self, incoming_bar: models.Bar) -> float:
+        """
+        Compute the specified simple moving average based on the incoming bar.
+
+        Args:
+            incoming_bar (models.Bar): Incoming bar with OHLCV data.
+
+        Returns:
+            float: Simple moving average value, or np.nan if insufficient data or
+            errors occur.
+        """
+        try:
+            mode = self.mode
+            if mode is models.XMAMode.OPEN:
+                current_value = incoming_bar.open
+            elif mode is models.XMAMode.HIGH:
+                current_value = incoming_bar.high
+            elif mode is models.XMAMode.LOW:
+                current_value = incoming_bar.low
+            elif mode is models.XMAMode.CLOSE:
+                current_value = incoming_bar.close
+            elif mode is models.XMAMode.TYPICAL_PRICE:
+                current_value = (
+                    incoming_bar.high + incoming_bar.low + incoming_bar.close
+                ) / 3.0
+            elif mode is models.XMAMode.WEIGHTED_CLOSE:
+                current_value = (
+                    incoming_bar.high + incoming_bar.low + 2.0 * incoming_bar.close
+                ) / 4.0
+            else:
+                console.logger.warning(
+                    f"Unsupported XMAMode: {mode}; using close price"
+                )
+                current_value = incoming_bar.close
+
+            if not np.isfinite(current_value):
+                console.logger.warning(
+                    f"Invalid value extracted: {current_value} (mode={mode.name}); "
+                    f"using np.nan"
+                )
+                return np.nan
+
+            with self._lock:
+                self._window.append(current_value)
+                if len(self._window) < self.period:
+                    return np.nan
+                sma_value = sum(self._window) / self.period
+            return sma_value
+
+        except Exception as e:
+            console.logger.warning(f"SMA calculation failed: {e}; returning np.nan")
+            return np.nan