onesecondtrader 0.27.0__tar.gz → 0.29.0__tar.gz

{onesecondtrader-0.27.0 → onesecondtrader-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.27.0
+Version: 0.29.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.27.0 → onesecondtrader-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.27.0"
+version = "0.29.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.27.0 → onesecondtrader-0.29.0}/src/onesecondtrader/brokers/__init__.py

@@ -1,5 +1,7 @@
 __all__ = [
     "BrokerBase",
+    "SimulatedBroker",
 ]
 
 from .base import BrokerBase
+from .simulated import SimulatedBroker

onesecondtrader-0.29.0/src/onesecondtrader/brokers/simulated.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader import events, messaging, models
+from .base import BrokerBase
+
+
+@dataclasses.dataclass
+class _PendingOrder:
+    # Order state tracked by the broker, distinct from the OrderSubmission event
+    order_id: uuid.UUID
+    symbol: str
+    order_type: models.OrderType
+    side: models.OrderSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+
+
+class SimulatedBroker(BrokerBase):
+    commission_per_unit: float = 0.0
+    minimum_commission_per_order: float = 0.0
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        self._pending_market_orders: dict[uuid.UUID, _PendingOrder] = {}
+        self._pending_limit_orders: dict[uuid.UUID, _PendingOrder] = {}
+        self._pending_stop_orders: dict[uuid.UUID, _PendingOrder] = {}
+        self._pending_stop_limit_orders: dict[uuid.UUID, _PendingOrder] = {}
+
+        super().__init__(event_bus)
+        self._subscribe(events.BarReceived)
+
+    def _on_event(self, event: events.EventBase) -> None:
+        match event:
+            case events.BarReceived() as bar:
+                self._on_bar(bar)
+            case _:
+                super()._on_event(event)
+
+    def _on_bar(self, event: events.BarReceived) -> None:
+        self._process_market_orders(event)
+        self._process_stop_orders(event)
+        self._process_stop_limit_orders(event)
+        self._process_limit_orders(event)
+
+    def _process_market_orders(self, event: events.BarReceived) -> None:
+        for order_id, order in list(self._pending_market_orders.items()):
+            if order.symbol != event.symbol:
+                continue
+
+            self._publish(
+                events.OrderFilled(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=order.order_id,
+                    symbol=order.symbol,
+                    side=order.side,
+                    quantity_filled=order.quantity,
+                    fill_price=event.open,
+                    commission=max(
+                        order.quantity * self.commission_per_unit,
+                        self.minimum_commission_per_order,
+                    ),
+                )
+            )
+            del self._pending_market_orders[order_id]
+
+    def _process_stop_orders(self, event: events.BarReceived) -> None:
+        for order_id, order in list(self._pending_stop_orders.items()):
+            if order.symbol != event.symbol:
+                continue
+
+            # This is for mypy, it has already been validated on submission
+            assert order.stop_price is not None
+
+            triggered = False
+            match order.side:
+                case models.OrderSide.BUY:
+                    triggered = event.high >= order.stop_price
+                case models.OrderSide.SELL:
+                    triggered = event.low <= order.stop_price
+
+            if not triggered:
+                continue
+
+            fill_price = 0.0
+            match order.side:
+                case models.OrderSide.BUY:
+                    fill_price = max(order.stop_price, event.open)
+                case models.OrderSide.SELL:
+                    fill_price = min(order.stop_price, event.open)
+
+            self._publish(
+                events.OrderFilled(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=order.order_id,
+                    symbol=order.symbol,
+                    side=order.side,
+                    quantity_filled=order.quantity,
+                    fill_price=fill_price,
+                    commission=max(
+                        order.quantity * self.commission_per_unit,
+                        self.minimum_commission_per_order,
+                    ),
+                )
+            )
+            del self._pending_stop_orders[order_id]
+
+    def _process_stop_limit_orders(self, event: events.BarReceived) -> None:
+        for order_id, order in list(self._pending_stop_limit_orders.items()):
+            if order.symbol != event.symbol:
+                continue
+
+            # This is for mypy, it has already been validated on submission
+            assert order.stop_price is not None
+
+            triggered = False
+            match order.side:
+                case models.OrderSide.BUY:
+                    triggered = event.high >= order.stop_price
+                case models.OrderSide.SELL:
+                    triggered = event.low <= order.stop_price
+
+            if not triggered:
+                continue
+
+            limit_order = dataclasses.replace(order, order_type=models.OrderType.LIMIT)
+            self._pending_limit_orders[order_id] = limit_order
+            del self._pending_stop_limit_orders[order_id]
+
+    def _process_limit_orders(self, event: events.BarReceived) -> None:
+        for order_id, order in list(self._pending_limit_orders.items()):
+            if order.symbol != event.symbol:
+                continue
+
+            # This is for mypy, it has already been validated on submission
+            assert order.limit_price is not None
+
+            triggered = False
+            match order.side:
+                case models.OrderSide.BUY:
+                    triggered = event.low <= order.limit_price
+                case models.OrderSide.SELL:
+                    triggered = event.high >= order.limit_price
+
+            if not triggered:
+                continue
+
+            fill_price = 0.0
+            match order.side:
+                case models.OrderSide.BUY:
+                    fill_price = min(order.limit_price, event.open)
+                case models.OrderSide.SELL:
+                    fill_price = max(order.limit_price, event.open)
+
+            self._publish(
+                events.OrderFilled(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=order.order_id,
+                    symbol=order.symbol,
+                    side=order.side,
+                    quantity_filled=order.quantity,
+                    fill_price=fill_price,
+                    commission=max(
+                        order.quantity * self.commission_per_unit,
+                        self.minimum_commission_per_order,
+                    ),
+                )
+            )
+            del self._pending_limit_orders[order_id]
+
+    def _reject_if_invalid_submission(self, event: events.OrderSubmission) -> bool:
+        is_invalid = event.quantity <= 0
+
+        match event.order_type:
+            case models.OrderType.LIMIT:
+                is_invalid = (
+                    is_invalid or event.limit_price is None or event.limit_price <= 0
+                )
+            case models.OrderType.STOP:
+                is_invalid = (
+                    is_invalid or event.stop_price is None or event.stop_price <= 0
+                )
+            case models.OrderType.STOP_LIMIT:
+                is_invalid = is_invalid or (
+                    event.limit_price is None
+                    or event.limit_price <= 0
+                    or event.stop_price is None
+                    or event.stop_price <= 0
+                )
+
+        if is_invalid:
+            # Use event timestamp to maintain simulated time consistency in backtesting
+            self._publish(
+                events.OrderSubmissionRejected(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=event.system_order_id,
+                )
+            )
+
+        return is_invalid
+
+    def _on_submit_order(self, event: events.OrderSubmission) -> None:
+        if self._reject_if_invalid_submission(event):
+            return
+
+        order = _PendingOrder(
+            order_id=event.system_order_id,
+            symbol=event.symbol,
+            order_type=event.order_type,
+            side=event.side,
+            quantity=event.quantity,
+            limit_price=event.limit_price,
+            stop_price=event.stop_price,
+        )
+
+        match order.order_type:
+            case models.OrderType.MARKET:
+                self._pending_market_orders[order.order_id] = order
+            case models.OrderType.LIMIT:
+                self._pending_limit_orders[order.order_id] = order
+            case models.OrderType.STOP:
+                self._pending_stop_orders[order.order_id] = order
+            case models.OrderType.STOP_LIMIT:
+                self._pending_stop_limit_orders[order.order_id] = order
+
+        # Use event timestamp to maintain simulated time consistency in backtesting
+        self._publish(
+            events.OrderSubmissionAccepted(
+                ts_event=event.ts_event,
+                ts_broker=event.ts_event,
+                associated_order_id=order.order_id,
+            )
+        )
+
+    def _on_cancel_order(self, event: events.OrderCancellation) -> None:
+        order_id = event.system_order_id
+
+        removed = False
+        for pending_orders in (
+            self._pending_market_orders,
+            self._pending_limit_orders,
+            self._pending_stop_orders,
+            self._pending_stop_limit_orders,
+        ):
+            if order_id in pending_orders:
+                del pending_orders[order_id]
+                removed = True
+                break
+
+        # Use event timestamp to maintain simulated time consistency in backtesting
+        if removed:
+            self._publish(
+                events.OrderCancellationAccepted(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=order_id,
+                )
+            )
+        else:
+            self._publish(
+                events.OrderCancellationRejected(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=order_id,
+                )
+            )
+
+    def _reject_if_invalid_modification(self, event: events.OrderModification) -> bool:
+        is_invalid = (
+            (event.quantity is not None and event.quantity <= 0)
+            or (event.limit_price is not None and event.limit_price <= 0)
+            or (event.stop_price is not None and event.stop_price <= 0)
+        )
+
+        if is_invalid:
+            # Use event timestamp to maintain simulated time consistency in backtesting
+            self._publish(
+                events.OrderModificationRejected(
+                    ts_event=event.ts_event,
+                    ts_broker=event.ts_event,
+                    associated_order_id=event.system_order_id,
+                )
+            )
+
+        return is_invalid
+
+    def _on_modify_order(self, event: events.OrderModification) -> None:
+        if self._reject_if_invalid_modification(event):
+            return
+
+        order_id = event.system_order_id
+
+        for pending_orders in (
+            self._pending_market_orders,
+            self._pending_limit_orders,
+            self._pending_stop_orders,
+            self._pending_stop_limit_orders,
+        ):
+            if order_id in pending_orders:
+                order = pending_orders[order_id]
+
+                new_quantity = (
+                    event.quantity if event.quantity is not None else order.quantity
+                )
+                new_limit_price = (
+                    event.limit_price
+                    if event.limit_price is not None
+                    else order.limit_price
+                )
+                new_stop_price = (
+                    event.stop_price
+                    if event.stop_price is not None
+                    else order.stop_price
+                )
+
+                pending_orders[order_id] = dataclasses.replace(
+                    order,
+                    quantity=new_quantity,
+                    limit_price=new_limit_price,
+                    stop_price=new_stop_price,
+                )
+
+                # Use event timestamp to maintain simulated time consistency in backtesting
+                self._publish(
+                    events.OrderModificationAccepted(
+                        ts_event=event.ts_event,
+                        ts_broker=event.ts_event,
+                        associated_order_id=order_id,
+                    )
+                )
+                return
+
+        # Use event timestamp to maintain simulated time consistency in backtesting
+        self._publish(
+            events.OrderModificationRejected(
+                ts_event=event.ts_event,
+                ts_broker=event.ts_event,
+                associated_order_id=order_id,
+            )
+        )

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

@@ -0,0 +1,5 @@
+__all__ = [
+    "Indicator",
+]
+
+from .base import Indicator

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

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import abc
+import collections
+import threading
+
+import numpy as np
+
+from onesecondtrader import events
+
+
+class Indicator(abc.ABC):
+    def __init__(self, max_history: int = 100, plot_at: int = 99) -> None:
+        self._lock = threading.Lock()
+        self._max_history = max(1, int(max_history))
+        # Keyed by symbol only - each strategy subscribes to one timeframe, so the indicator only sees bars from that timeframe.
+        self._history: dict[str, collections.deque[float]] = {}
+        # 0 = main price chart, 1-98 = subcharts, 99 = no plot
+        self._plot_at = plot_at
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
+        pass
+
+    def update(self, incoming_bar: events.BarReceived) -> None:
+        symbol = incoming_bar.symbol
+        value = self._compute_indicator(incoming_bar)
+        with self._lock:
+            if symbol not in self._history:
+                self._history[symbol] = collections.deque(maxlen=self._max_history)
+            self._history[symbol].append(value)
+
+    def latest(self, symbol: str) -> float:
+        with self._lock:
+            history = self._history.get(symbol, collections.deque())
+            return history[-1] if history else np.nan
+
+    def history(self, symbol: str) -> collections.deque[float]:
+        with self._lock:
+            h = self._history.get(symbol, collections.deque())
+            return collections.deque(h, maxlen=self._max_history)
+
+    @property
+    def plot_at(self) -> int:
+        return self._plot_at

{onesecondtrader-0.27.0 → onesecondtrader-0.29.0}/src/onesecondtrader/messaging/eventbus.py

@@ -34,6 +34,7 @@ class EventBus:
             self._subscribers.discard(subscriber)
 
     def publish(self, event: events.bases.EventBase) -> None:
+        # Intentionally matches exact event types only, not parent classes
         with self._lock:
             subscribers = self._per_event_subscriptions[type(event)].copy()
         for subscriber in subscribers: