onesecondtrader 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

onesecondtrader/brokers/__init__.py

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

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/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/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:

onesecondtrader/messaging/subscriber.py

@@ -36,10 +36,12 @@ class Subscriber(abc.ABC):
             self._thread.join()
 
     def _subscribe(self, *event_types: type[events.bases.EventBase]) -> None:
-        # Call as last line of subclass __init__ to avoid receiving events before fully initialized
         for event_type in event_types:
             self._event_bus.subscribe(self, event_type)
 
+    def _publish(self, event: events.bases.EventBase) -> None:
+        self._event_bus.publish(event)
+
     def _event_loop(self) -> None:
         while True:
             event = self._queue.get()

{onesecondtrader-0.26.0.dist-info → onesecondtrader-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.26.0
+Version: 0.28.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.26.0.dist-info → onesecondtrader-0.28.0.dist-info}/RECORD

@@ -1,16 +1,19 @@
 onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/brokers/__init__.py,sha256=YofzD0qlrfo_BzL6gwiHb9by7Webp36TQ_1O5EV0uzY,124
+onesecondtrader/brokers/base.py,sha256=b6Xq2gBUdy3RTpnUfpUiNSXwbuq_bRIjXJ-s89Xu7nE,1345
+onesecondtrader/brokers/simulated.py,sha256=pJvZ7b76xAs-NBbOX_v78IJgVrdnuTLCadqj8kYQ5sg,12694
 onesecondtrader/events/__init__.py,sha256=IOlFRdiOXz93SpvkpKL8wr1954d_8olKSB1n9mlTL3Y,898
 onesecondtrader/events/bases.py,sha256=g-ykq2jgcitIAueRurUlqAq0jINQwuhSWi_khAniPHw,662
 onesecondtrader/events/market.py,sha256=IfHuIGfp_IUiw-dFay4c4RYmkoNzshxbhuWTglBqfN0,509
 onesecondtrader/events/requests.py,sha256=2KXwSckiar9-fy8wkN3vcSIeOkeBfeo_XhUhrNKEd2Q,831
 onesecondtrader/events/responses.py,sha256=w_BH1nkkPyxQjh30EXEVFcUGDoMprFc2PuAaqpVrQ8A,1436
 onesecondtrader/messaging/__init__.py,sha256=vMRDabHBgse_vZRTRFtnU8M8v2sY_o4pHjGzgu3hp3E,115
-onesecondtrader/messaging/eventbus.py,sha256=rTBDmtXKnUAVdOBeLyIn2pJmBLz9AszHGIcuOcVhEQI,1501
-onesecondtrader/messaging/subscriber.py,sha256=Vg8po_h47qMPm_qN6OauIBiCE179cszjy3NCd493__s,2103
+onesecondtrader/messaging/eventbus.py,sha256=Y8VbDZlEz8Q6KcCkfXRKsVIixsctBMRW1a5ANw297Ls,1576
+onesecondtrader/messaging/subscriber.py,sha256=ImpFmu5IstLXLoKVMaebmLp5MXN6225vHLdTL1ZOPvw,2106
 onesecondtrader/models/__init__.py,sha256=cH5xyniz78MQjM9_-fFdP1ZW6FFLTmayMwQauFO23bU,135
 onesecondtrader/models/data.py,sha256=TqUvTtjpmzTJT8ZdTYnlVoyI7Qck2IsseCazWZxJgD0,173
 onesecondtrader/models/orders.py,sha256=y6Ar-6fMqaOd_hRnRGvfWUF0Z13H_2hfTOW3ROOk0A8,254
-onesecondtrader-0.26.0.dist-info/METADATA,sha256=4JFvirUCpSuaYhLlTru35NFBcLc0M0kjEMTjRZPqe5w,9682
-onesecondtrader-0.26.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.26.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.26.0.dist-info/RECORD,,
+onesecondtrader-0.28.0.dist-info/METADATA,sha256=heQCUCvcEuwy8W9mzjn6fm9_wR8sGP1T7weYq9b19eQ,9682
+onesecondtrader-0.28.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+onesecondtrader-0.28.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.28.0.dist-info/RECORD,,