onesecondtrader 0.53.0__tar.gz → 0.55.0__tar.gz

{onesecondtrader-0.53.0 → onesecondtrader-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.53.0
+Version: 0.55.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.53.0 → onesecondtrader-0.55.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.53.0"
+version = "0.55.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.55.0/src/onesecondtrader/datafeeds/__init__.py

@@ -0,0 +1,11 @@
+"""
+Provides data feed components for ingesting market data into the system.
+"""
+
+from .base import DatafeedBase
+from .simulated import SimulatedDatafeed
+
+__all__ = [
+    "DatafeedBase",
+    "SimulatedDatafeed",
+]

onesecondtrader-0.55.0/src/onesecondtrader/datafeeds/base.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import abc
+
+from onesecondtrader import events, messaging, models
+
+
+class DatafeedBase(abc.ABC):
+    """
+    Abstract base class for market data feed implementations.
+
+    A data feed is responsible for connecting to an external data source, managing symbol and bar-period subscriptions, and publishing market data events onto the system event bus.
+
+    Concrete subclasses implement the mechanics of connectivity, subscription handling, and lifecycle management for a specific data source.
+    """
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Initialize the data feed with an event bus.
+
+        parameters:
+            event_bus:
+                Event bus used to publish market data events produced by this data feed.
+        """
+        self._event_bus = event_bus
+
+    def _publish(self, event: events.EventBase) -> None:
+        """
+        Publish a market data event to the event bus.
+
+        This method is intended for use by subclasses to forward incoming data from the external source into the internal event-driven system.
+
+        parameters:
+            event:
+                Event instance to be published.
+        """
+        self._event_bus.publish(event)
+
+    @abc.abstractmethod
+    def connect(self) -> None:
+        """
+        Establish a connection to the underlying data source.
+
+        Implementations should perform any required setup, authentication, or resource allocation needed before subscriptions can be registered.
+        """
+        pass
+
+    @abc.abstractmethod
+    def disconnect(self) -> None:
+        """
+        Terminate the connection to the underlying data source.
+
+        Implementations should release resources and ensure that no further events are published after disconnection.
+        """
+        pass
+
+    @abc.abstractmethod
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Subscribe to market data for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols to subscribe to, interpreted according to the conventions of the underlying data source.
+            bar_period:
+                Bar aggregation period specifying the granularity of market data.
+        """
+        pass
+
+    @abc.abstractmethod
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Cancel existing subscriptions for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols for which subscriptions should be removed.
+            bar_period:
+                Bar aggregation period associated with the subscriptions.
+        """
+        pass
+
+    def wait_until_complete(self) -> None:
+        """
+        Block until the data feed has completed all pending work.
+
+        This method may be overridden by subclasses that perform asynchronous ingestion or background processing.
+        The default implementation does nothing.
+        """
+        pass

onesecondtrader-0.55.0/src/onesecondtrader/datafeeds/simulated.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import itertools
+import os
+import sqlite3
+import threading
+
+from onesecondtrader import events, messaging, models
+from onesecondtrader.datafeeds.base import DatafeedBase
+
+_RTYPE_MAP = {
+    models.BarPeriod.SECOND: 32,
+    models.BarPeriod.MINUTE: 33,
+    models.BarPeriod.HOUR: 34,
+    models.BarPeriod.DAY: 35,
+}
+
+_RTYPE_TO_BAR_PERIOD = {v: k for k, v in _RTYPE_MAP.items()}
+
+
+class SimulatedDatafeed(DatafeedBase):
+    """
+    Simulated market data feed backed by a secmaster SQLite database.
+
+    This datafeed replays historical OHLCV bars from a secmaster database, resolving symbols
+    via time-bounded symbology mappings. Bars are delivered in timestamp order, with all bars
+    sharing the same timestamp published before calling `wait_until_system_idle`.
+
+    Subclasses must set `publisher_name`, `dataset`, and `symbol_type` as class attributes to
+    scope the feed to a specific data source. The database must contain publishers with numeric
+    `source_instrument_id` values; symbol-only publishers (e.g., yfinance) are not supported.
+    """
+
+    db_path: str = ""
+    publisher_name: str = ""
+    dataset: str = ""
+    symbol_type: str = ""
+    price_scale: float = 1e9
+    start_ts: int | None = None
+    end_ts: int | None = None
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Parameters:
+            event_bus:
+                Event bus used to publish bar events and synchronize with subscribers.
+        """
+        super().__init__(event_bus)
+        self._db_path = self.db_path or os.environ.get(
+            "SECMASTER_DB_PATH", "secmaster.db"
+        )
+        if not self.publisher_name:
+            raise ValueError("publisher_name is required")
+        if not self.dataset:
+            raise ValueError("dataset is required")
+        if not self.symbol_type:
+            raise ValueError("symbol_type is required")
+        self._subscriptions: set[tuple[str, models.BarPeriod]] = set()
+        self._subscriptions_lock = threading.Lock()
+        self._connection: sqlite3.Connection | None = None
+        self._thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+        self._publisher_id: int | None = None
+
+    def connect(self) -> None:
+        """
+        Open a connection to the secmaster database and resolve the publisher.
+
+        If already connected, this method returns immediately.
+        """
+        if self._connection:
+            return
+        self._connection = sqlite3.connect(self._db_path, check_same_thread=False)
+        self._connection.execute("PRAGMA foreign_keys = ON")
+        self._connection.execute("PRAGMA journal_mode = WAL")
+        row = self._connection.execute(
+            "SELECT publisher_id FROM publishers WHERE name = ? AND dataset = ?",
+            (self.publisher_name, self.dataset),
+        ).fetchone()
+        if row is None:
+            raise ValueError(
+                f"Publisher not found: {self.publisher_name}/{self.dataset}"
+            )
+        self._publisher_id = row[0]
+
+    def disconnect(self) -> None:
+        """
+        Close the database connection and stop any active streaming.
+
+        If not connected, this method returns immediately.
+        """
+        if not self._connection:
+            return
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+        self._connection.close()
+        self._connection = None
+        self._publisher_id = None
+
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Register symbols for bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to subscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.update((s, bar_period) for s in symbols)
+
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Remove symbols from bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to unsubscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.difference_update((s, bar_period) for s in symbols)
+
+    def wait_until_complete(self) -> None:
+        """
+        Stream all subscribed bars and block until delivery is complete.
+
+        Bars are published in timestamp order. After each timestamp batch, the method
+        waits for all event bus subscribers to become idle before proceeding.
+        """
+        with self._subscriptions_lock:
+            has_subscriptions = bool(self._subscriptions)
+        if not has_subscriptions:
+            return
+        if self._thread is None or not self._thread.is_alive():
+            self._stop_event.clear()
+            self._thread = threading.Thread(
+                target=self._stream,
+                name=self.__class__.__name__,
+                daemon=False,
+            )
+            self._thread.start()
+        self._thread.join()
+
+    def _stream(self) -> None:
+        if not self._connection or self._publisher_id is None:
+            return
+
+        with self._subscriptions_lock:
+            subscriptions = list(self._subscriptions)
+        if not subscriptions:
+            return
+
+        symbols = list({symbol for symbol, _ in subscriptions})
+        rtypes = list({_RTYPE_MAP[bp] for _, bp in subscriptions})
+        subscription_set = {(symbol, _RTYPE_MAP[bp]) for symbol, bp in subscriptions}
+
+        params: list = [self._publisher_id, self.symbol_type]
+        params.extend(symbols)
+        params.extend(rtypes)
+        if self.start_ts is not None:
+            params.append(self.start_ts)
+        if self.end_ts is not None:
+            params.append(self.end_ts)
+
+        query = f"""
+            SELECT s.symbol, o.rtype, o.ts_event, o.open, o.high, o.low, o.close, o.volume
+            FROM ohlcv o
+            JOIN instruments i ON i.instrument_id = o.instrument_id
+            JOIN symbology s
+              ON s.publisher_ref = i.publisher_ref
+             AND s.source_instrument_id = i.source_instrument_id
+             AND date(o.ts_event / 1000000000, 'unixepoch') >= s.start_date
+             AND date(o.ts_event / 1000000000, 'unixepoch') <= s.end_date
+            WHERE i.publisher_ref = ?
+              AND s.symbol_type = ?
+              AND s.symbol IN ({",".join("?" * len(symbols))})
+              AND o.rtype IN ({",".join("?" * len(rtypes))})
+              {"AND o.ts_event >= ?" if self.start_ts is not None else ""}
+              {"AND o.ts_event <= ?" if self.end_ts is not None else ""}
+            ORDER BY o.ts_event, s.symbol
+        """
+
+        rows = self._connection.execute(query, params)
+
+        def to_bar(row):
+            symbol, rtype, ts_event, open_, high, low, close, volume = row
+            if (symbol, rtype) not in subscription_set:
+                return None
+            return events.market.BarReceived(
+                ts_event_ns=ts_event,
+                symbol=symbol,
+                bar_period=_RTYPE_TO_BAR_PERIOD[rtype],
+                open=open_ / self.price_scale,
+                high=high / self.price_scale,
+                low=low / self.price_scale,
+                close=close / self.price_scale,
+                volume=volume,
+            )
+
+        for _, group in itertools.groupby(rows, key=lambda r: r[2]):
+            if self._stop_event.is_set():
+                return
+            for bar in filter(None, map(to_bar, group)):
+                self._publish(bar)
+            self._event_bus.wait_until_system_idle()

onesecondtrader-0.55.0/src/onesecondtrader/events/requests/order_submission.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader import models
+from onesecondtrader.events.requests.base import RequestBase
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
+class OrderSubmissionRequest(RequestBase):
+    """
+    Event representing a request to submit a new order to a brokers.
+
+    The `system_order_id` is a unique identifier assigned by the system to the order submission request by default at object creation.
+
+    | Field             | Type                       | Semantics                                                                  |
+    |-------------------|----------------------------|----------------------------------------------------------------------------|
+    | `ts_event_ns`     | `int`                      | Time at which the submission request was issued, as UTC epoch nanoseconds. |
+    | `ts_created_ns`   | `int`                      | Time at which the event object was created, as UTC epoch nanoseconds.      |
+    | `system_order_id` | `uuid.UUID`                | System-assigned unique identifier for the order submission.                |
+    | `symbol`          | `str`                      | Identifier of the traded instrument.                                       |
+    | `order_type`      | `models.OrderType`         | Execution constraint of the order.                                         |
+    | `side`            | `models.TradeSide`         | Direction of the trade.                                                    |
+    | `quantity`        | `float`                    | Requested order quantity.                                                  |
+    | `limit_price`     | `float` or `None`          | Limit price, if applicable to the order type.                              |
+    | `stop_price`      | `float` or `None`          | Stop price, if applicable to the order type.                               |
+    | `action`          | `models.ActionType` or `None` | Intent of the order from the strategy's perspective (e.g., entry, exit).   |
+    | `signal`          | `str` or `None`            | Optional signal name or identifier that triggered this order.              |
+    """
+
+    system_order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    order_type: models.OrderType
+    side: models.TradeSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+    action: models.ActionType | None = None
+    signal: str | None = None

{onesecondtrader-0.53.0 → onesecondtrader-0.55.0}/src/onesecondtrader/models/__init__.py

@@ -2,6 +2,7 @@
 Defines the fundamental domain concepts used throughout the trading system.
 """
 
+from .action_types import ActionType
 from .bar_fields import BarField
 from .bar_period import BarPeriod
 from .order_types import OrderType
@@ -13,6 +14,7 @@ from .rejection_reasons import (
 from .trade_sides import TradeSide
 
 __all__ = [
+    "ActionType",
     "BarField",
     "BarPeriod",
     "OrderType",

onesecondtrader-0.55.0/src/onesecondtrader/models/action_types.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import enum
+
+
+class ActionType(enum.Enum):
+    """
+    Enumeration of trading action types.
+
+    `ActionType` specifies the intent or purpose of an order from the strategy's perspective,
+    describing what the order is meant to accomplish in terms of position management.
+
+    | Value         | Semantics                                                                  |
+    |---------------|----------------------------------------------------------------------------|
+    | `ENTRY`       | Opens a new position (direction-agnostic).                                 |
+    | `ENTRY_LONG`  | Opens a new long position.                                                 |
+    | `ENTRY_SHORT` | Opens a new short position.                                                |
+    | `EXIT`        | Closes an existing position (direction-agnostic).                          |
+    | `EXIT_LONG`   | Closes an existing long position.                                          |
+    | `EXIT_SHORT`  | Closes an existing short position.                                         |
+    | `ADD`         | Increases the size of an existing position.                                |
+    | `REDUCE`      | Decreases the size of an existing position without fully closing it.       |
+    | `REVERSE`     | Closes the current position and opens a new one in the opposite direction. |
+    """
+
+    ENTRY = enum.auto()
+    ENTRY_LONG = enum.auto()
+    ENTRY_SHORT = enum.auto()
+    EXIT = enum.auto()
+    EXIT_LONG = enum.auto()
+    EXIT_SHORT = enum.auto()
+    ADD = enum.auto()
+    REDUCE = enum.auto()
+    REVERSE = enum.auto()

{onesecondtrader-0.53.0 → onesecondtrader-0.55.0}/src/onesecondtrader/secmaster/utils.py

@@ -559,6 +559,8 @@ def _ingest_symbology(
             batch,
         )
 
+    _validate_no_overlapping_symbology(con, publisher_id, symbol_type)
+
     logger.info(
         "Completed symbology ingest from %s (%d mappings)", json_path.name, count
     )
@@ -566,6 +568,37 @@ def _ingest_symbology(
     return count
 
 
+def _validate_no_overlapping_symbology(
+    con: sqlite3.Connection,
+    publisher_id: int,
+    symbol_type: str,
+) -> None:
+    query = """
+        WITH ordered AS (
+            SELECT
+                symbol,
+                start_date,
+                end_date,
+                LEAD(start_date) OVER (
+                    PARTITION BY symbol ORDER BY start_date
+                ) AS next_start
+            FROM symbology
+            WHERE publisher_ref = ? AND symbol_type = ?
+        )
+        SELECT symbol, start_date, end_date, next_start
+        FROM ordered
+        WHERE next_start IS NOT NULL AND end_date > next_start
+        LIMIT 1
+    """
+    row = con.execute(query, (publisher_id, symbol_type)).fetchone()
+    if row:
+        symbol, start, end, next_start = row
+        raise ValueError(
+            f"Overlapping symbology detected for symbol={symbol!r}: "
+            f"segment [{start}, {end}] overlaps with next segment starting {next_start}"
+        )
+
+
 def _enable_bulk_loading(con: sqlite3.Connection) -> None:
     con.execute("PRAGMA journal_mode = WAL")
     con.execute("PRAGMA synchronous = NORMAL")

onesecondtrader-0.55.0/src/onesecondtrader/strategies/__init__.py

@@ -0,0 +1,11 @@
+"""
+Provides a base class for creating custom trading strategies and provides example strategies.
+"""
+
+from .base import StrategyBase
+from .examples import SMACrossover
+
+__all__ = [
+    "StrategyBase",
+    "SMACrossover",
+]

onesecondtrader-0.55.0/src/onesecondtrader/strategies/base.py

@@ -0,0 +1,539 @@
+from __future__ import annotations
+
+import abc
+import dataclasses
+import enum
+import uuid
+from types import SimpleNamespace
+
+import pandas as pd
+
+from onesecondtrader import events, indicators, messaging, models
+
+
+@dataclasses.dataclass
+class ParamSpec:
+    """
+    Specification for a strategy parameter.
+
+    Defines the default value and optional constraints for a configurable strategy parameter.
+    Used to declare tunable parameters that can be overridden at strategy instantiation.
+
+    | Field     | Type                                      | Semantics                                                    |
+    |-----------|-------------------------------------------|--------------------------------------------------------------|
+    | `default` | `int`, `float`, `str`, `bool`, or `Enum`  | Default value of the parameter.                              |
+    | `min`     | `int`, `float`, or `None`                 | Minimum allowed value, if applicable.                        |
+    | `max`     | `int`, `float`, or `None`                 | Maximum allowed value, if applicable.                        |
+    | `step`    | `int`, `float`, or `None`                 | Step size for parameter sweeps, if applicable.               |
+    | `choices` | `list` or `None`                          | Explicit list of allowed values, if applicable.              |
+    """
+
+    default: int | float | str | bool | enum.Enum
+    min: int | float | None = None
+    max: int | float | None = None
+    step: int | float | None = None
+    choices: list | None = None
+
+    @property
+    def resolved_choices(self) -> list | None:
+        """
+        Return the effective list of allowed values for this parameter.
+
+        If `choices` is explicitly set, returns that list.
+        If `default` is an enum member, returns all members of that enum type.
+        Otherwise, returns `None`.
+        """
+        if self.choices is not None:
+            return self.choices
+        if isinstance(self.default, enum.Enum):
+            return list(type(self.default))
+        return None
+
+
+@dataclasses.dataclass
+class OrderRecord:
+    """
+    Internal record of an order submitted by a strategy.
+
+    Tracks the state of an order from submission through fill or cancellation.
+
+    | Field             | Type               | Semantics                                           |
+    |-------------------|--------------------|-----------------------------------------------------|
+    | `order_id`        | `uuid.UUID`        | System-assigned unique identifier for the order.    |
+    | `symbol`          | `str`              | Identifier of the traded instrument.                |
+    | `order_type`      | `models.OrderType` | Execution constraint of the order.                  |
+    | `side`            | `models.TradeSide` | Direction of the trade.                             |
+    | `quantity`        | `float`            | Requested order quantity.                           |
+    | `limit_price`     | `float` or `None`  | Limit price, if applicable to the order type.       |
+    | `stop_price`      | `float` or `None`  | Stop price, if applicable to the order type.        |
+    | `signal`          | `str` or `None`    | Optional signal name associated with the order.     |
+    | `filled_quantity` | `float`            | Cumulative quantity filled for this order.          |
+    """
+
+    order_id: uuid.UUID
+    symbol: str
+    order_type: models.OrderType
+    side: models.TradeSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+    signal: str | None = None
+    filled_quantity: float = 0.0
+
+
+@dataclasses.dataclass
+class FillRecord:
+    """
+    Internal record of a fill received by a strategy.
+
+    Captures execution details for a single fill event.
+
+    | Field        | Type               | Semantics                                                 |
+    |--------------|--------------------|-----------------------------------------------------------|
+    | `fill_id`    | `uuid.UUID`        | System-assigned unique identifier for the fill.           |
+    | `order_id`   | `uuid.UUID`        | Identifier of the order associated with the fill.         |
+    | `symbol`     | `str`              | Identifier of the traded instrument.                      |
+    | `side`       | `models.TradeSide` | Trade direction of the executed quantity.                 |
+    | `quantity`   | `float`            | Quantity executed in this fill.                           |
+    | `price`      | `float`            | Execution price of the fill.                              |
+    | `commission` | `float`            | Commission or fee associated with the fill.               |
+    | `ts_event`   | `pd.Timestamp`     | Timestamp at which the fill was observed by the strategy. |
+    """
+
+    fill_id: uuid.UUID
+    order_id: uuid.UUID
+    symbol: str
+    side: models.TradeSide
+    quantity: float
+    price: float
+    commission: float
+    ts_event: pd.Timestamp
+
+
+class StrategyBase(messaging.Subscriber, abc.ABC):
+    """
+    Abstract base class for trading strategies.
+
+    A strategy subscribes to market data and order events, maintains position state,
+    and submits orders through the event bus. Subclasses implement `on_bar` to define
+    trading logic and optionally override `setup` to register indicators.
+
+    Class Attributes:
+        name:
+            Human-readable name of the strategy.
+        symbols:
+            List of instrument symbols the strategy trades.
+        parameters:
+            Dictionary mapping parameter names to their specifications.
+    """
+
+    name: str = ""
+    symbols: list[str] = []
+    parameters: dict[str, ParamSpec] = {}
+
+    def __init__(self, event_bus: messaging.EventBus, **overrides) -> None:
+        """
+        Initialize the strategy and start event processing.
+
+        Parameters:
+            event_bus:
+                Event bus used for subscribing to and publishing events.
+            **overrides:
+                Parameter values to override defaults defined in `parameters`.
+        """
+        super().__init__(event_bus)
+
+        for name, spec in self.parameters.items():
+            value = overrides.get(name, spec.default)
+            setattr(self, name, value)
+
+        self._subscribe(
+            events.market.BarReceived,
+            events.responses.OrderAccepted,
+            events.responses.ModificationAccepted,
+            events.responses.CancellationAccepted,
+            events.responses.OrderRejected,
+            events.responses.ModificationRejected,
+            events.responses.CancellationRejected,
+            events.orders.FillEvent,
+            events.orders.OrderExpired,
+        )
+
+        self._current_symbol: str = ""
+        self._current_ts: pd.Timestamp = pd.Timestamp.now(tz="UTC")
+        self._indicators: list[indicators.IndicatorBase] = []
+
+        self._fills: dict[str, list[FillRecord]] = {}
+        self._positions: dict[str, float] = {}
+        self._avg_prices: dict[str, float] = {}
+        self._pending_orders: dict[uuid.UUID, OrderRecord] = {}
+        self._submitted_orders: dict[uuid.UUID, OrderRecord] = {}
+        self._submitted_modifications: dict[uuid.UUID, OrderRecord] = {}
+        self._submitted_cancellations: dict[uuid.UUID, OrderRecord] = {}
+
+        # OHLCV as indicators for history access: self.bar.close.history
+        self.bar = SimpleNamespace(
+            open=self.add_indicator(indicators.Open()),
+            high=self.add_indicator(indicators.High()),
+            low=self.add_indicator(indicators.Low()),
+            close=self.add_indicator(indicators.Close()),
+            volume=self.add_indicator(indicators.Volume()),
+        )
+
+        # Hook for subclasses to register indicators without overriding __init__
+        self.setup()
+
+    def add_indicator(self, ind: indicators.IndicatorBase) -> indicators.IndicatorBase:
+        """
+        Register an indicator with the strategy.
+
+        Registered indicators are automatically updated on each bar event.
+
+        Parameters:
+            ind:
+                Indicator instance to register.
+
+        Returns:
+            The registered indicator instance.
+        """
+        self._indicators.append(ind)
+        return ind
+
+    @property
+    def position(self) -> float:
+        """
+        Return the current position for the active symbol.
+
+        The active symbol is set by the most recently processed bar event.
+        """
+        return self._positions.get(self._current_symbol, 0.0)
+
+    @property
+    def avg_price(self) -> float:
+        """
+        Return the average entry price for the current position on the active symbol.
+
+        Returns zero if there is no open position.
+        """
+        return self._avg_prices.get(self._current_symbol, 0.0)
+
+    def submit_order(
+        self,
+        order_type: models.OrderType,
+        side: models.TradeSide,
+        quantity: float,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+        action: models.ActionType | None = None,
+        signal: str | None = None,
+    ) -> uuid.UUID:
+        """
+        Submit a new order for the active symbol.
+
+        Parameters:
+            order_type:
+                Execution constraint of the order.
+            side:
+                Direction of the trade.
+            quantity:
+                Requested order quantity.
+            limit_price:
+                Limit price, if applicable to the order type.
+            stop_price:
+                Stop price, if applicable to the order type.
+            action:
+                Intent of the order from the strategy's perspective (e.g., entry, exit).
+            signal:
+                Optional signal name associated with the order.
+
+        Returns:
+            System-assigned unique identifier for the submitted order.
+        """
+        order_id = uuid.uuid4()
+
+        event = events.requests.OrderSubmissionRequest(
+            ts_event_ns=int(self._current_ts.value),
+            system_order_id=order_id,
+            symbol=self._current_symbol,
+            order_type=order_type,
+            side=side,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+            action=action,
+            signal=signal,
+        )
+
+        order = OrderRecord(
+            order_id=order_id,
+            symbol=self._current_symbol,
+            order_type=order_type,
+            side=side,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+            signal=signal,
+        )
+
+        self._submitted_orders[order_id] = order
+        self._publish(event)
+        return order_id
+
+    def submit_modification(
+        self,
+        order_id: uuid.UUID,
+        quantity: float | None = None,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+    ) -> bool:
+        """
+        Submit a modification request for a pending order.
+
+        Parameters:
+            order_id:
+                Identifier of the order to modify.
+            quantity:
+                Updated order quantity, or `None` to keep unchanged.
+            limit_price:
+                Updated limit price, or `None` to keep unchanged.
+            stop_price:
+                Updated stop price, or `None` to keep unchanged.
+
+        Returns:
+            `True` if the modification request was submitted, `False` if the order was not found.
+        """
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.requests.OrderModificationRequest(
+            ts_event_ns=int(self._current_ts.value),
+            system_order_id=order_id,
+            symbol=original_order.symbol,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+        )
+
+        modified_order = OrderRecord(
+            order_id=order_id,
+            symbol=original_order.symbol,
+            order_type=original_order.order_type,
+            side=original_order.side,
+            quantity=quantity if quantity is not None else original_order.quantity,
+            limit_price=(
+                limit_price if limit_price is not None else original_order.limit_price
+            ),
+            stop_price=(
+                stop_price if stop_price is not None else original_order.stop_price
+            ),
+            signal=original_order.signal,
+            filled_quantity=original_order.filled_quantity,
+        )
+
+        self._submitted_modifications[order_id] = modified_order
+        self._publish(event)
+        return True
+
+    def submit_cancellation(self, order_id: uuid.UUID) -> bool:
+        """
+        Submit a cancellation request for a pending order.
+
+        Parameters:
+            order_id:
+                Identifier of the order to cancel.
+
+        Returns:
+            `True` if the cancellation request was submitted, `False` if the order was not found.
+        """
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.requests.OrderCancellationRequest(
+            ts_event_ns=int(self._current_ts.value),
+            system_order_id=order_id,
+            symbol=original_order.symbol,
+        )
+
+        self._submitted_cancellations[order_id] = original_order
+        self._publish(event)
+        return True
+
+    def _on_event(self, event: events.EventBase) -> None:
+        match event:
+            case events.market.BarReceived() as bar_event:
+                self._on_bar_received(bar_event)
+            case events.responses.OrderAccepted() as accepted:
+                self._on_order_submission_accepted(accepted)
+            case events.responses.ModificationAccepted() as accepted:
+                self._on_order_modification_accepted(accepted)
+            case events.responses.CancellationAccepted() as accepted:
+                self._on_order_cancellation_accepted(accepted)
+            case events.responses.OrderRejected() as rejected:
+                self._on_order_submission_rejected(rejected)
+            case events.responses.ModificationRejected() as rejected:
+                self._on_order_modification_rejected(rejected)
+            case events.responses.CancellationRejected() as rejected:
+                self._on_order_cancellation_rejected(rejected)
+            case events.orders.FillEvent() as filled:
+                self._on_order_filled(filled)
+            case events.orders.OrderExpired() as expired:
+                self._on_order_expired(expired)
+            case _:
+                return
+
+    def _on_bar_received(self, event: events.market.BarReceived) -> None:
+        if event.symbol not in self.symbols:
+            return
+        if event.bar_period != self.bar_period:  # type: ignore[attr-defined]
+            return
+
+        self._current_symbol = event.symbol
+        self._current_ts = pd.Timestamp(event.ts_event_ns, tz="UTC")
+
+        for ind in self._indicators:
+            ind.update(event)
+
+        self._emit_processed_bar(event)
+        self.on_bar(event)
+
+    def _emit_processed_bar(self, event: events.market.BarReceived) -> None:
+        ohlcv_names = {"OPEN", "HIGH", "LOW", "CLOSE", "VOLUME"}
+
+        indicator_values = {
+            f"{ind.plot_at:02d}_{ind.name}": ind.latest(event.symbol)
+            for ind in self._indicators
+            if ind.name not in ohlcv_names
+        }
+
+        processed_bar = events.market.BarProcessed(
+            ts_event_ns=event.ts_event_ns,
+            symbol=event.symbol,
+            bar_period=event.bar_period,
+            open=event.open,
+            high=event.high,
+            low=event.low,
+            close=event.close,
+            volume=event.volume,
+            indicators=indicator_values,
+        )
+
+        self._publish(processed_bar)
+
+    def _on_order_submission_accepted(
+        self, event: events.responses.OrderAccepted
+    ) -> None:
+        order = self._submitted_orders.pop(event.associated_order_id, None)
+        if order is not None:
+            self._pending_orders[event.associated_order_id] = order
+
+    def _on_order_modification_accepted(
+        self, event: events.responses.ModificationAccepted
+    ) -> None:
+        modified_order = self._submitted_modifications.pop(
+            event.associated_order_id, None
+        )
+        if modified_order is not None:
+            self._pending_orders[event.associated_order_id] = modified_order
+
+    def _on_order_cancellation_accepted(
+        self, event: events.responses.CancellationAccepted
+    ) -> None:
+        self._submitted_cancellations.pop(event.associated_order_id, None)
+        self._pending_orders.pop(event.associated_order_id, None)
+
+    def _on_order_submission_rejected(
+        self, event: events.responses.OrderRejected
+    ) -> None:
+        self._submitted_orders.pop(event.associated_order_id, None)
+
+    def _on_order_modification_rejected(
+        self, event: events.responses.ModificationRejected
+    ) -> None:
+        self._submitted_modifications.pop(event.associated_order_id, None)
+
+    def _on_order_cancellation_rejected(
+        self, event: events.responses.CancellationRejected
+    ) -> None:
+        self._submitted_cancellations.pop(event.associated_order_id, None)
+
+    def _on_order_filled(self, event: events.orders.FillEvent) -> None:
+        order = self._pending_orders.get(event.associated_order_id)
+        if order:
+            order.filled_quantity += event.quantity_filled
+            if order.filled_quantity >= order.quantity:
+                self._pending_orders.pop(event.associated_order_id)
+
+        fill = FillRecord(
+            fill_id=event.fill_id,
+            order_id=event.associated_order_id,
+            symbol=event.symbol,
+            side=event.side,
+            quantity=event.quantity_filled,
+            price=event.fill_price,
+            commission=event.commission,
+            ts_event=pd.Timestamp(event.ts_event_ns, tz="UTC"),
+        )
+
+        self._fills.setdefault(event.symbol, []).append(fill)
+        self._update_position(event)
+
+    def _update_position(self, event: events.orders.FillEvent) -> None:
+        symbol = event.symbol
+        fill_qty = event.quantity_filled
+        fill_price = event.fill_price
+
+        signed_qty = 0.0
+        match event.side:
+            case models.TradeSide.BUY:
+                signed_qty = fill_qty
+            case models.TradeSide.SELL:
+                signed_qty = -fill_qty
+
+        old_pos = self._positions.get(symbol, 0.0)
+        old_avg = self._avg_prices.get(symbol, 0.0)
+        new_pos = old_pos + signed_qty
+
+        if new_pos == 0.0:
+            new_avg = 0.0
+        elif old_pos == 0.0:
+            new_avg = fill_price
+        elif (old_pos > 0 and signed_qty > 0) or (old_pos < 0 and signed_qty < 0):
+            new_avg = (old_avg * abs(old_pos) + fill_price * abs(signed_qty)) / abs(
+                new_pos
+            )
+        else:
+            if abs(new_pos) <= abs(old_pos):
+                new_avg = old_avg
+            else:
+                new_avg = fill_price
+
+        self._positions[symbol] = new_pos
+        self._avg_prices[symbol] = new_avg
+
+    def _on_order_expired(self, event: events.orders.OrderExpired) -> None:
+        self._pending_orders.pop(event.associated_order_id, None)
+
+    def setup(self) -> None:
+        """
+        Hook for subclasses to register indicators and perform initialization.
+
+        Called at the end of `__init__`. Override this method to register indicators
+        using `add_indicator` without needing to override `__init__`.
+        """
+        pass
+
+    @abc.abstractmethod
+    def on_bar(self, event: events.market.BarReceived) -> None:
+        """
+        Handle a bar event for a subscribed symbol.
+
+        Called after all registered indicators have been updated. Subclasses implement
+        this method to define trading logic.
+
+        Parameters:
+            event:
+                Bar event containing OHLCV data for the current bar.
+        """
+        pass

onesecondtrader-0.55.0/src/onesecondtrader/strategies/examples.py

@@ -0,0 +1,48 @@
+from onesecondtrader import events, indicators, models
+from .base import StrategyBase, ParamSpec
+
+
+class SMACrossover(StrategyBase):
+    name = "SMA Crossover"
+    parameters = {
+        "bar_period": ParamSpec(default=models.BarPeriod.SECOND),
+        "fast_period": ParamSpec(default=20, min=5, max=100, step=1),
+        "slow_period": ParamSpec(default=100, min=10, max=500, step=1),
+        "quantity": ParamSpec(default=1.0, min=0.1, max=100.0, step=0.1),
+    }
+
+    def setup(self) -> None:
+        self.fast_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.fast_period)  # type: ignore[attr-defined]
+        )
+        self.slow_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.slow_period)  # type: ignore[attr-defined]
+        )
+
+    def on_bar(self, event: events.market.BarReceived) -> None:
+        sym = event.symbol
+        if (
+            self.fast_sma[sym, -2] <= self.slow_sma[sym, -2]
+            and self.fast_sma.latest(sym) > self.slow_sma.latest(sym)
+            and self.position <= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET,
+                models.TradeSide.BUY,
+                self.quantity,  # type: ignore[attr-defined]
+                action=models.ActionType.ENTRY,
+                signal="sma_crossover_up",
+            )
+
+        if (
+            self.fast_sma[sym, -2] >= self.slow_sma[sym, -2]
+            and self.fast_sma.latest(sym) < self.slow_sma.latest(sym)
+            and self.position >= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET,
+                models.TradeSide.SELL,
+                self.quantity,  # type: ignore[attr-defined]
+                action=models.ActionType.EXIT,
+                signal="sma_crossover_down",
+            )

onesecondtrader-0.53.0/src/onesecondtrader/events/requests/order_submission.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import uuid
-
-from onesecondtrader import models
-from onesecondtrader.events.requests.base import RequestBase
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
-class OrderSubmissionRequest(RequestBase):
-    """
-    Event representing a request to submit a new order to a brokers.
-
-    The `system_order_id` is a unique identifier assigned by the system to the order submission request by default at object creation.
-
-    | Field             | Type                     | Semantics                                                                  |
-    |-------------------|--------------------------|----------------------------------------------------------------------------|
-    | `ts_event_ns`     | `int`                    | Time at which the submission request was issued, as UTC epoch nanoseconds. |
-    | `ts_created_ns`   | `int`                    | Time at which the event object was created, as UTC epoch nanoseconds.      |
-    | `system_order_id` | `uuid.UUID`              | System-assigned unique identifier for the order submission.                |
-    | `symbol`          | `str`                    | Identifier of the traded instrument.                                       |
-    | `order_type`      | `models.OrderType`       | Execution constraint of the order.                                         |
-    | `side`            | `models.TradeSide`       | Direction of the trade.                                                    |
-    | `quantity`        | `float`                  | Requested order quantity.                                                  |
-    | `limit_price`     | `float` or `None`        | Limit price, if applicable to the order type.                              |
-    | `stop_price`      | `float` or `None`        | Stop price, if applicable to the order type.                               |
-    """
-
-    system_order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    order_type: models.OrderType
-    side: models.TradeSide
-    quantity: float
-    limit_price: float | None = None
-    stop_price: float | None = None