onesecondtrader 0.22.0__py3-none-any.whl → 0.49.0__py3-none-any.whl

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/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/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/models/__init__.py

@@ -0,0 +1,23 @@
+"""
+Defines the fundamental domain concepts used throughout the trading system.
+"""
+
+from .bar_fields import BarField
+from .bar_period import BarPeriod
+from .order_types import OrderType
+from .rejection_reasons import (
+    OrderRejectionReason,
+    CancellationRejectionReason,
+    ModificationRejectionReason,
+)
+from .trade_sides import TradeSide
+
+__all__ = [
+    "BarField",
+    "BarPeriod",
+    "OrderType",
+    "TradeSide",
+    "OrderRejectionReason",
+    "CancellationRejectionReason",
+    "ModificationRejectionReason",
+]

onesecondtrader/models/bar_fields.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import enum
+
+
+class BarField(enum.Enum):
+    """
+    Enumeration of bar fields used as indicator inputs.
+
+    | Value    | Semantics                          |
+    |----------|------------------------------------|
+    | `OPEN`   | Bar's opening value.               |
+    | `HIGH`   | Bar's highest value.               |
+    | `LOW`    | Bar's lowest value.                |
+    | `CLOSE`  | Bar's closing value.               |
+    | `VOLUME` | Bar's traded volume.               |
+    """
+
+    OPEN = enum.auto()
+    HIGH = enum.auto()
+    LOW = enum.auto()
+    CLOSE = enum.auto()
+    VOLUME = enum.auto()

onesecondtrader/models/bar_period.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import enum
+
+
+class BarPeriod(enum.Enum):
+    """
+    Enumeration of bar aggregation periods.
+
+    | Value    | Semantics            |
+    |----------|----------------------|
+    | `SECOND` | Duration of 1 second.|
+    | `MINUTE` | Duration of 1 minute.|
+    | `HOUR`   | Duration of 1 hour.  |
+    | `DAY`    | Duration of 1 day.   |
+    """
+
+    SECOND = enum.auto()
+    MINUTE = enum.auto()
+    HOUR = enum.auto()
+    DAY = enum.auto()

onesecondtrader/models/order_types.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import enum
+
+
+class OrderType(enum.Enum):
+    """
+    Enumeration of order execution types.
+
+    | Value        | Semantics                                                   |
+    |--------------|-------------------------------------------------------------|
+    | `LIMIT`      | Executable only at the specified limit price or better.     |
+    | `MARKET`     | Executable immediately at the best available market price.  |
+    | `STOP`       | Becomes a market order once the stop price is reached.      |
+    | `STOP_LIMIT` | Becomes a limit order once the stop price is reached.       |
+    """
+
+    LIMIT = enum.auto()
+    MARKET = enum.auto()
+    STOP = enum.auto()
+    STOP_LIMIT = enum.auto()

onesecondtrader/models/rejection_reasons.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import enum
+
+
+class OrderRejectionReason(enum.Enum):
+    """
+    Enumeration of canonical order rejection reasons.
+
+    This enumeration defines the system-level classification of order rejection causes.
+    It provides a stable, broker-agnostic taxonomy for programmatic handling of rejected orders.
+
+    | Value     | Semantics                                                                 |
+    |-----------|---------------------------------------------------------------------------|
+    | `UNKNOWN` | The rejection reason could not be classified into a known category.       |
+    """
+
+    UNKNOWN = enum.auto()
+
+
+class ModificationRejectionReason(enum.Enum):
+    """
+    Enumeration of canonical order modification rejection reasons.
+
+    This enumeration defines the system-level classification of reasons for which an order modification request may be rejected by a broker.
+    It provides a stable, broker-agnostic taxonomy intended for programmatic handling and observability of modification rejections.
+
+    | Value     | Semantics                                                                        |
+    |-----------|----------------------------------------------------------------------------------|
+    | `UNKNOWN` | The modification rejection reason could not be classified into a known category. |
+    """
+
+    UNKNOWN = enum.auto()
+
+
+class CancellationRejectionReason(enum.Enum):
+    """
+    Enumeration of canonical order cancellation rejection reasons.
+
+    This enumeration defines the system-level classification of reasons for which an order cancellation request may be rejected by a broker.
+    It provides a stable, broker-agnostic taxonomy intended for programmatic handling and observability of cancellation rejections.
+
+    | Value     | Semantics                                                                        |
+    |-----------|----------------------------------------------------------------------------------|
+    | `UNKNOWN` | The cancellation rejection reason could not be classified into a known category. |
+    """
+
+    UNKNOWN = enum.auto()

onesecondtrader/models/trade_sides.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import enum
+
+
+class TradeSide(enum.Enum):
+    """
+    Enumeration of trade direction.
+
+    `TradeSide` specifies the direction of change applied to the (net) signed position
+    quantity from the perspective of the trading account.
+
+    | Value   | Semantics                                      |
+    |---------|------------------------------------------------|
+    | `BUY`   | Increases the signed position quantity.        |
+    | `SELL`  | Decreases the signed position quantity.        |
+    """
+
+    BUY = enum.auto()
+    SELL = enum.auto()

{onesecondtrader-0.22.0.dist-info → onesecondtrader-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.22.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
@@ -11,9 +11,15 @@ 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: databento (>=0.69.0,<0.70.0)
+Requires-Dist: fastapi (>=0.128.0,<0.129.0)
+Requires-Dist: ib-async (>=2.1.0,<3.0.0)
 Requires-Dist: matplotlib (>=3.10.7,<4.0.0)
+Requires-Dist: mplfinance (>=0.12.10b0,<0.13.0)
 Requires-Dist: pandas (>=2.3.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
+Requires-Dist: uvicorn (>=0.40.0,<0.41.0)
 Description-Content-Type: text/markdown
 
 # OneSecondTrader
@@ -111,7 +117,7 @@ graph TD
         B["<b>Code Quality Checks</b><br/>• Ruff Check & Format<br/>• MyPy Type Checking<br/>• Tests & Doctests"]
         C["<b>Security Checks</b><br/>• Gitleaks Secret Detection"]
         D["<b>File Validation</b><br/>• YAML/TOML/JSON Check<br/>• End-of-file Fixer<br/>• Large Files Check<br/>• Merge Conflict Check<br/>• Debug Statements Check"]
-        E["<b>Generate API Documentation</b> via <kbd>scripts/generate_api_docs.py</kbd><br/>• Auto-generate docs<br/>• Stage changes"]
+        E["<b>Generate Reference Documentation</b> via <kbd>scripts/generate_reference_docs.py</kbd><br/>• Auto-generate docs<br/>• Stage changes"]
     end
     B --> C --> D --> E
 

onesecondtrader-0.49.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/events/__init__.py,sha256=1T7hJA6afxClEXvvnbXtHu9iMyhduRdJZWlg4ObWaKE,222
+onesecondtrader/events/base.py,sha256=WpLo1bSKJe7Poh2IuDDCiBYZo9vE8mkq3cQlUpyTXsY,850
+onesecondtrader/events/market/__init__.py,sha256=49z6maexBIDkAjIfkLbYzSZWEbyTpQ_HEEgT0eacrDo,132
+onesecondtrader/events/market/bar_processed.py,sha256=NsCDGC21ykmioJoITspoAuz5mesKP0_hkM4UumWk1eU,1993
+onesecondtrader/events/market/bar_received.py,sha256=_LJEZ7P-AfYQEIkXYNt-toO9_WG_XTS2Y86tb-qdOVU,1961
+onesecondtrader/events/orders/__init__.py,sha256=IgVmiVUGMwDlFnL1ItAgvPwmkqEMJDLgQK8aJIKQ1Ic,164
+onesecondtrader/events/orders/base.py,sha256=3zTY8JMkXiOV35k0tp6rZZ9X7pDN40Btm0SFT5Mq3nw,1650
+onesecondtrader/events/orders/expirations.py,sha256=nW_28REmNNyxLpKzkAhwnC_mMqw00SqRediiZW8Zyz8,1465
+onesecondtrader/events/orders/fills.py,sha256=IDSCR7__AAPWm69noV9TeE2C8LukZv-ju8yjDfgmA9w,2772
+onesecondtrader/events/requests/__init__.py,sha256=PWVAjNdgHWZArWXz9HU7E-6ZgMdfCpn4wAJiM9a5q6E,325
+onesecondtrader/events/requests/base.py,sha256=XXdiOy946hW3LmF7lMShi10kPtGftl928aPMDwEdnao,1084
+onesecondtrader/events/requests/order_cancellation.py,sha256=X_ZMOx09gz0Hf8hvDE1OahqK1SoH4nw9IOMJIdbbTKs,1029
+onesecondtrader/events/requests/order_modification.py,sha256=Tks2mXn1bkuOVLsk98tTk3E2CTld6SF1IwmkCvGvsc8,1538
+onesecondtrader/events/requests/order_submission.py,sha256=ejLBEWJ7pzhXWcTncK1x_ZJfcaC21CnuEz00wvi1q-8,2155
+onesecondtrader/events/responses/__init__.py,sha256=ihg3zxjygLi-sA6wIbsm163ic8346WiAVtztb6ONy_4,409
+onesecondtrader/events/responses/base.py,sha256=tXOP3lvd6EqpC7NbfIJinUCI-KMz6xsR1YSQw5qNddk,1241
+onesecondtrader/events/responses/cancellations.py,sha256=HWF15Flz2JNOaZvArAjl9jLAt1NrQxB3MASG-0A2Z2Y,2941
+onesecondtrader/events/responses/modifications.py,sha256=ZQyehdwgAIg6HMmpQ5T_bWZ7yc4nfSeVwAGQ3T2O5-A,2968
+onesecondtrader/events/responses/orders.py,sha256=enkIUYRw9G3bzAq-it20XvXBew2gLg1mAm44m-12bns,2786
+onesecondtrader/indicators/__init__.py,sha256=i-syRqCdQdC2BLL-7bDBcdl2Mll1LgE7hi2GleCJ4HI,366
+onesecondtrader/indicators/base.py,sha256=iGfgOj1B_LRGBeh7VjM5OjxoYnSxV7JZUP1C3O_dfmE,4653
+onesecondtrader/indicators/market_fields.py,sha256=Znyii0egBkJT3CFlYhQ5ArRNidmBLF0TzgCr2AWu5CA,4306
+onesecondtrader/indicators/moving_averages.py,sha256=Ej3Vg-K4Kf93J3MS6av2J8FRP1Kqx4G6yNZj1QfE9lU,3411
+onesecondtrader/models/__init__.py,sha256=XWL6aNLwAA2JQMoqK2PY-_CwigV0ighx4zwGQVdmtCs,529
+onesecondtrader/models/bar_fields.py,sha256=GnLBL08ueUr35w2dAbKwOBWrdBS98OC9r0T2NifwTH8,646
+onesecondtrader/models/bar_period.py,sha256=J8ncVtcAxR52uD0nbC8Knds_GUP5wiuNj5rAKq4vv-4,475
+onesecondtrader/models/order_types.py,sha256=SiJamarLQ7zkHzHLLbd86I_TeZrQJ4QEIMqNHj4dxXU,737
+onesecondtrader/models/rejection_reasons.py,sha256=BToLmPholsP9GcLGZ874nQJpehZ1yB1SFyYqlf3AOwc,2127
+onesecondtrader/models/trade_sides.py,sha256=Pf9BpxoUxqgKC_EKAExfSqgfIIK9NW-RpJES0XHRF-8,583
+onesecondtrader-0.49.0.dist-info/METADATA,sha256=EFqtCI8r8EWYjn-l1LOkaWIsF0QrUZyq1UFA2WI56Dk,9951
+onesecondtrader-0.49.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+onesecondtrader-0.49.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.49.0.dist-info/RECORD,,

{onesecondtrader-0.22.0.dist-info → onesecondtrader-0.49.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.0
 Root-Is-Purelib: true
 Tag: py3-none-any