onesecondtrader 0.22.0__tar.gz → 0.32.0__tar.gz

{onesecondtrader-0.22.0 → onesecondtrader-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.22.0
+Version: 0.32.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.22.0 → onesecondtrader-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.22.0"
+version = "0.32.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.32.0/src/onesecondtrader/__init__.py

@@ -0,0 +1,5 @@
+from onesecondtrader import brokers as brokers
+from onesecondtrader import events as events
+from onesecondtrader import indicators as indicators
+from onesecondtrader import messaging as messaging
+from onesecondtrader import models as models

onesecondtrader-0.32.0/src/onesecondtrader/brokers/__init__.py

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

onesecondtrader-0.32.0/src/onesecondtrader/brokers/base.py

@@ -0,0 +1,39 @@
+import abc
+
+from onesecondtrader import events, messaging
+
+
+class BrokerBase(messaging.Subscriber):
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        super().__init__(event_bus)
+        self._subscribe(
+            events.requests.OrderSubmission,
+            events.requests.OrderCancellation,
+            events.requests.OrderModification,
+        )
+
+    def _on_event(self, event: events.bases.EventBase) -> None:
+        match event:
+            case events.requests.OrderSubmission() as submit_order:
+                self._on_submit_order(submit_order)
+            case events.requests.OrderCancellation() as cancel_order:
+                self._on_cancel_order(cancel_order)
+            case events.requests.OrderModification() as modify_order:
+                self._on_modify_order(modify_order)
+            case _:
+                return
+
+    @abc.abstractmethod
+    def _on_submit_order(self, event: events.requests.OrderSubmission) -> None:
+        pass
+
+    @abc.abstractmethod
+    def _on_cancel_order(self, event: events.requests.OrderCancellation) -> None:
+        pass
+
+    @abc.abstractmethod
+    def _on_modify_order(self, event: events.requests.OrderModification) -> None:
+        pass
+
+    def _respond(self, response_event: events.bases.BrokerResponseEvent) -> None:
+        self._publish(response_event)

onesecondtrader-0.32.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.32.0/src/onesecondtrader/events/__init__.py

@@ -0,0 +1,33 @@
+__all__ = [
+    "EventBase",
+    "MarketEvent",
+    "BrokerRequestEvent",
+    "BrokerResponseEvent",
+    "BarReceived",
+    "BarProcessed",
+    "OrderSubmission",
+    "OrderModification",
+    "OrderCancellation",
+    "OrderSubmissionAccepted",
+    "OrderSubmissionRejected",
+    "OrderModificationAccepted",
+    "OrderModificationRejected",
+    "OrderCancellationAccepted",
+    "OrderCancellationRejected",
+    "OrderFilled",
+    "OrderExpired",
+]
+
+from .bases import EventBase, MarketEvent, BrokerRequestEvent, BrokerResponseEvent
+from .market import BarReceived, BarProcessed
+from .requests import OrderSubmission, OrderModification, OrderCancellation
+from .responses import (
+    OrderSubmissionAccepted,
+    OrderSubmissionRejected,
+    OrderModificationAccepted,
+    OrderModificationRejected,
+    OrderCancellationAccepted,
+    OrderCancellationRejected,
+    OrderFilled,
+    OrderExpired,
+)

onesecondtrader-0.32.0/src/onesecondtrader/events/bases.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import dataclasses
+import pandas as pd
+import uuid
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class EventBase:
+    ts_event: pd.Timestamp
+    ts_created: pd.Timestamp = dataclasses.field(
+        default_factory=lambda: pd.Timestamp.now(tz="UTC")
+    )
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class MarketEvent(EventBase):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerRequestEvent(EventBase):
+    system_order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerResponseEvent(EventBase):
+    ts_broker: pd.Timestamp
+    associated_order_id: uuid.UUID

onesecondtrader-0.32.0/src/onesecondtrader/events/market.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import dataclasses
+
+from onesecondtrader import models
+from . import bases
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BarReceived(bases.MarketEvent):
+    symbol: str
+    bar_period: models.data.BarPeriod
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BarProcessed(BarReceived):
+    indicators: dict[str, float] = dataclasses.field(default_factory=dict)

onesecondtrader-0.32.0/src/onesecondtrader/events/requests.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader import models
+from . import bases
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderSubmission(bases.BrokerRequestEvent):
+    system_order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    symbol: str
+    order_type: models.orders.OrderType
+    side: models.orders.OrderSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderCancellation(bases.BrokerRequestEvent):
+    symbol: str
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderModification(bases.BrokerRequestEvent):
+    symbol: str
+    quantity: float | None = None
+    limit_price: float | None = None
+    stop_price: float | None = None

onesecondtrader-0.32.0/src/onesecondtrader/events/responses.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader import models
+from . import bases
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderSubmissionAccepted(bases.BrokerResponseEvent):
+    broker_order_id: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderSubmissionRejected(bases.BrokerResponseEvent):
+    reason: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderModificationAccepted(bases.BrokerResponseEvent):
+    broker_order_id: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderModificationRejected(bases.BrokerResponseEvent):
+    reason: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderCancellationAccepted(bases.BrokerResponseEvent):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderCancellationRejected(bases.BrokerResponseEvent):
+    reason: str | None = None
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderFilled(bases.BrokerResponseEvent):
+    fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    broker_fill_id: str | None = None
+    symbol: str
+    side: models.orders.OrderSide
+    quantity_filled: float
+    fill_price: float
+    commission: float
+    exchange: str = "SIMULATED"
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class OrderExpired(bases.BrokerResponseEvent):
+    pass

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

@@ -0,0 +1,13 @@
+__all__ = [
+    "Indicator",
+    "Open",
+    "High",
+    "Low",
+    "Close",
+    "Volume",
+    "SimpleMovingAverage",
+]
+
+from .base import Indicator
+from .bar import Open, High, Low, Close, Volume
+from .averages import SimpleMovingAverage

onesecondtrader-0.32.0/src/onesecondtrader/indicators/averages.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import collections
+
+import numpy as np
+
+from onesecondtrader import events, models
+from .base import Indicator
+
+
+class SimpleMovingAverage(Indicator):
+    def __init__(
+        self,
+        period: int = 200,
+        max_history: int = 100,
+        input_source: models.InputSource = models.InputSource.CLOSE,
+        plot_at: int = 0,
+    ) -> None:
+        super().__init__(max_history=max_history, plot_at=plot_at)
+        self.period: int = max(1, int(period))
+        self.input_source: models.InputSource = input_source
+        self._window: dict[str, collections.deque[float]] = {}
+
+    @property
+    def name(self) -> str:
+        return f"SMA_{self.period}_{self.input_source.name}"
+
+    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
+        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_input(incoming_bar)
+        window.append(value)
+        if len(window) < self.period:
+            return np.nan
+        return sum(window) / self.period
+
+    def _extract_input(self, incoming_bar: events.BarReceived) -> float:
+        match self.input_source:
+            case models.InputSource.OPEN:
+                return incoming_bar.open
+            case models.InputSource.HIGH:
+                return incoming_bar.high
+            case models.InputSource.LOW:
+                return incoming_bar.low
+            case models.InputSource.CLOSE:
+                return incoming_bar.close
+            case models.InputSource.VOLUME:
+                return (
+                    float(incoming_bar.volume)
+                    if incoming_bar.volume is not None
+                    else np.nan
+                )
+            case _:
+                return incoming_bar.close