onesecondtrader 0.31.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

onesecondtrader/__init__.py

@@ -1,5 +1,49 @@
-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
+__all__ = [
+    "BarPeriod",
+    "BarProcessed",
+    "BarReceived",
+    "BrokerBase",
+    "Close",
+    "FillRecord",
+    "High",
+    "Indicator",
+    "InputSource",
+    "Low",
+    "Open",
+    "OrderFilled",
+    "OrderRecord",
+    "OrderSide",
+    "OrderSubmission",
+    "OrderType",
+    "SimpleMovingAverage",
+    "SimulatedBroker",
+    "SMACrossover",
+    "StrategyBase",
+    "Volume",
+]
+
+from onesecondtrader.brokers import BrokerBase, SimulatedBroker
+from onesecondtrader.events import (
+    BarProcessed,
+    BarReceived,
+    OrderFilled,
+    OrderSubmission,
+)
+from onesecondtrader.indicators import (
+    Close,
+    High,
+    Indicator,
+    Low,
+    Open,
+    SimpleMovingAverage,
+    Volume,
+)
+from onesecondtrader.models import (
+    BarPeriod,
+    FillRecord,
+    InputSource,
+    OrderRecord,
+    OrderSide,
+    OrderType,
+)
+from onesecondtrader.strategies import SMACrossover, StrategyBase

onesecondtrader/indicators/base.py

@@ -13,9 +13,8 @@ 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._current_symbol: str = ""
+        self._history_data: dict[str, collections.deque[float]] = {}
         self._plot_at = plot_at
 
     @property
@@ -29,22 +28,33 @@ class Indicator(abc.ABC):
 
     def update(self, incoming_bar: events.BarReceived) -> None:
         symbol = incoming_bar.symbol
+        self._current_symbol = 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)
+            if symbol not in self._history_data:
+                self._history_data[symbol] = collections.deque(maxlen=self._max_history)
+            self._history_data[symbol].append(value)
 
-    def latest(self, symbol: str) -> float:
+    @property
+    def latest(self) -> float:
         with self._lock:
-            history = self._history.get(symbol, collections.deque())
-            return history[-1] if history else np.nan
+            h = self._history_data.get(self._current_symbol, collections.deque())
+            return h[-1] if h else np.nan
 
-    def history(self, symbol: str) -> collections.deque[float]:
+    @property
+    def history(self) -> collections.deque[float]:
         with self._lock:
-            h = self._history.get(symbol, collections.deque())
+            h = self._history_data.get(self._current_symbol, collections.deque())
             return collections.deque(h, maxlen=self._max_history)
 
+    def __getitem__(self, index: int) -> float:
+        # Returns np.nan on out-of-bounds access. Since np.nan comparisons always
+        # return False, strategies can skip explicit length checks.
+        try:
+            return self.history[index]
+        except IndexError:
+            return np.nan
+
     @property
     def plot_at(self) -> int:
         return self._plot_at

onesecondtrader/models/__init__.py

@@ -3,7 +3,10 @@ __all__ = [
     "InputSource",
     "OrderSide",
     "OrderType",
+    "OrderRecord",
+    "FillRecord",
 ]
 
 from .data import BarPeriod, InputSource
 from .orders import OrderSide, OrderType
+from .records import OrderRecord, FillRecord

onesecondtrader/models/records.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+import pandas as pd
+
+from . import orders
+
+
+@dataclasses.dataclass
+class OrderRecord:
+    order_id: uuid.UUID
+    symbol: str
+    order_type: orders.OrderType
+    side: orders.OrderSide
+    quantity: float
+    limit_price: float | None = None
+    stop_price: float | None = None
+    filled_quantity: float = 0.0
+
+
+@dataclasses.dataclass
+class FillRecord:
+    fill_id: uuid.UUID
+    order_id: uuid.UUID
+    symbol: str
+    side: orders.OrderSide
+    quantity: float
+    price: float
+    commission: float
+    ts_event: pd.Timestamp

onesecondtrader/strategies/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "StrategyBase",
+    "SMACrossover",
+]
+
+from .base import StrategyBase
+from .sma_crossover import SMACrossover

onesecondtrader/strategies/base.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import abc
+import uuid
+from types import SimpleNamespace
+
+import pandas as pd
+
+from onesecondtrader import events, indicators, messaging, models
+
+
+class StrategyBase(messaging.Subscriber, abc.ABC):
+    symbols: list[str] = []
+    bar_period: models.BarPeriod = models.BarPeriod.SECOND
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        super().__init__(event_bus)
+        self._subscribe(
+            events.BarReceived,
+            events.OrderSubmissionAccepted,
+            events.OrderModificationAccepted,
+            events.OrderCancellationAccepted,
+            events.OrderSubmissionRejected,
+            events.OrderModificationRejected,
+            events.OrderCancellationRejected,
+            events.OrderFilled,
+            events.OrderExpired,
+        )
+
+        self._current_symbol: str = ""
+        self._current_ts: pd.Timestamp = pd.Timestamp.now(tz="UTC")
+        self._indicators: list[indicators.Indicator] = []
+
+        self._fills: dict[str, list[models.FillRecord]] = {}
+        self._positions: dict[str, float] = {}
+        self._avg_prices: dict[str, float] = {}
+        self._pending_orders: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_orders: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_modifications: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_cancellations: dict[uuid.UUID, models.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.Indicator) -> indicators.Indicator:
+        self._indicators.append(ind)
+        return ind
+
+    @property
+    def position(self) -> float:
+        return self._positions.get(self._current_symbol, 0.0)
+
+    @property
+    def avg_price(self) -> float:
+        return self._avg_prices.get(self._current_symbol, 0.0)
+
+    def submit_order(
+        self,
+        order_type: models.OrderType,
+        side: models.OrderSide,
+        quantity: float,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+    ) -> uuid.UUID:
+        # Uses bar timestamp for backtest compatibility; ts_created tracks real wall-clock time
+        order_id = uuid.uuid4()
+
+        event = events.OrderSubmission(
+            ts_event=self._current_ts,
+            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,
+        )
+
+        order = models.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,
+        )
+
+        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:
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.OrderModification(
+            ts_event=self._current_ts,
+            system_order_id=order_id,
+            symbol=original_order.symbol,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+        )
+
+        modified_order = models.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
+            ),
+            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:
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.OrderCancellation(
+            ts_event=self._current_ts,
+            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.BarReceived() as bar_event:
+                self._on_bar_received(bar_event)
+            case events.OrderSubmissionAccepted() as accepted:
+                self._on_order_submission_accepted(accepted)
+            case events.OrderModificationAccepted() as accepted:
+                self._on_order_modification_accepted(accepted)
+            case events.OrderCancellationAccepted() as accepted:
+                self._on_order_cancellation_accepted(accepted)
+            case events.OrderSubmissionRejected() as rejected:
+                self._on_order_submission_rejected(rejected)
+            case events.OrderModificationRejected() as rejected:
+                self._on_order_modification_rejected(rejected)
+            case events.OrderCancellationRejected() as rejected:
+                self._on_order_cancellation_rejected(rejected)
+            case events.OrderFilled() as filled:
+                self._on_order_filled(filled)
+            case events.OrderExpired() as expired:
+                self._on_order_expired(expired)
+            case _:
+                return
+
+    def _on_bar_received(self, event: events.BarReceived) -> None:
+        if event.symbol not in self.symbols:
+            return
+        if event.bar_period != self.bar_period:
+            return
+
+        self._current_symbol = event.symbol
+        self._current_ts = event.ts_event
+
+        for ind in self._indicators:
+            ind.update(event)
+
+        self._emit_processed_bar(event)
+        self.on_bar(event)
+
+    def _emit_processed_bar(self, event: events.BarReceived) -> None:
+        ohlcv_names = {"OPEN", "HIGH", "LOW", "CLOSE", "VOLUME"}
+
+        indicator_values = {
+            f"{ind.plot_at:02d}_{ind.name}": ind.latest
+            for ind in self._indicators
+            if ind.name not in ohlcv_names
+        }
+
+        processed_bar = events.BarProcessed(
+            ts_event=event.ts_event,
+            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.OrderSubmissionAccepted
+    ) -> 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.OrderModificationAccepted
+    ) -> 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.OrderCancellationAccepted
+    ) -> 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.OrderSubmissionRejected
+    ) -> None:
+        self._submitted_orders.pop(event.associated_order_id, None)
+
+    def _on_order_modification_rejected(
+        self, event: events.OrderModificationRejected
+    ) -> None:
+        self._submitted_modifications.pop(event.associated_order_id, None)
+
+    def _on_order_cancellation_rejected(
+        self, event: events.OrderCancellationRejected
+    ) -> None:
+        self._submitted_cancellations.pop(event.associated_order_id, None)
+
+    def _on_order_filled(self, event: events.OrderFilled) -> None:
+        # Track partial fills: only remove order when fully filled
+        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 = models.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=event.ts_event,
+        )
+
+        self._fills.setdefault(event.symbol, []).append(fill)
+        self._update_position(event)
+
+    def _update_position(self, event: events.OrderFilled) -> None:
+        symbol = event.symbol
+        fill_qty = event.quantity_filled
+        fill_price = event.fill_price
+
+        signed_qty = 0.0
+        match event.side:
+            case models.OrderSide.BUY:
+                signed_qty = fill_qty
+            case models.OrderSide.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.OrderExpired) -> None:
+        self._pending_orders.pop(event.associated_order_id, None)
+
+    # Override to register indicators. Called at end of __init__.
+    def setup(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def on_bar(self, event: events.BarReceived) -> None:
+        pass

onesecondtrader/strategies/sma_crossover.py

@@ -0,0 +1,35 @@
+from onesecondtrader import events, indicators, models
+from .base import StrategyBase
+
+
+class SMACrossover(StrategyBase):
+    fast_period: int = 20
+    slow_period: int = 100
+    quantity: float = 1.0
+
+    def setup(self) -> None:
+        self.fast_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.fast_period)
+        )
+        self.slow_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.slow_period)
+        )
+
+    def on_bar(self, event: events.BarReceived) -> None:
+        if (
+            self.fast_sma[-2] <= self.slow_sma[-2]
+            and self.fast_sma.latest > self.slow_sma.latest
+            and self.position <= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET, models.OrderSide.BUY, self.quantity
+            )
+
+        if (
+            self.fast_sma[-2] >= self.slow_sma[-2]
+            and self.fast_sma.latest < self.slow_sma.latest
+            and self.position >= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET, models.OrderSide.SELL, self.quantity
+            )

{onesecondtrader-0.31.0.dist-info → onesecondtrader-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.31.0
+Version: 0.33.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.31.0.dist-info → onesecondtrader-0.33.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onesecondtrader/__init__.py,sha256=edb0kipMTx0p-utX0tc4J8IbhFrZprX200oxhX8LzH4,241
+onesecondtrader/__init__.py,sha256=CLUi62mHp8tBzp-58mig3M4SEhPELPihHfQQzcD9Nz8,901
 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
@@ -10,14 +10,18 @@ onesecondtrader/events/responses.py,sha256=w_BH1nkkPyxQjh30EXEVFcUGDoMprFc2PuAaq
 onesecondtrader/indicators/__init__.py,sha256=hRg3FCP1FT7LYOLzztybWn48gTR5QvewzzdELPYbdoY,239
 onesecondtrader/indicators/averages.py,sha256=DpRRdY5G5ze3jwNOV19PPjV6slA0IEeOOla67yChi2Y,1900
 onesecondtrader/indicators/bar.py,sha256=0H07mKNiUx5cE1fQvx1oPVY0R_MXcmAAgsLek175vTk,1115
-onesecondtrader/indicators/base.py,sha256=WGqjp9mmkR2PZ5ZC8zL9ddeTfUrB0hX3bjnq1W4HKuI,1658
+onesecondtrader/indicators/base.py,sha256=64HJD8JWBnUdR7PLd02N3hbNrRfKMjWHEKGeSyMRms8,1889
 onesecondtrader/messaging/__init__.py,sha256=vMRDabHBgse_vZRTRFtnU8M8v2sY_o4pHjGzgu3hp3E,115
 onesecondtrader/messaging/eventbus.py,sha256=Y8VbDZlEz8Q6KcCkfXRKsVIixsctBMRW1a5ANw297Ls,1576
 onesecondtrader/messaging/subscriber.py,sha256=ImpFmu5IstLXLoKVMaebmLp5MXN6225vHLdTL1ZOPvw,2106
-onesecondtrader/models/__init__.py,sha256=0J91ixFxYRaZ9t-dm_LVh7xh1ukb3G7H1GgelZg68as,167
+onesecondtrader/models/__init__.py,sha256=7amHCQ6BAhHKps0ke63E-zh8IJNmkdDogZq-PfBukMs,249
 onesecondtrader/models/data.py,sha256=fBmddVl6EXYC5u2UnvQ59DXAXeZeIb48KP1ZdeTL52A,322
 onesecondtrader/models/orders.py,sha256=y6Ar-6fMqaOd_hRnRGvfWUF0Z13H_2hfTOW3ROOk0A8,254
-onesecondtrader-0.31.0.dist-info/METADATA,sha256=OnASDmSzTXcJ2jmviGqe8qkF3xp8g3B4fAmicO3rDF0,9682
-onesecondtrader-0.31.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.31.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.31.0.dist-info/RECORD,,
+onesecondtrader/models/records.py,sha256=vdCWBtoDQs5R4iB_8_3fXkxWEvoCxOssk9XBnS4l7Vk,599
+onesecondtrader/strategies/__init__.py,sha256=5TlEckz3RnwZTs1Isj0wJ_9Og5R9MMXBL90Vu9b45io,126
+onesecondtrader/strategies/base.py,sha256=kIi6by4Y8YuB9gPMPMr2Unm5_i9SGAANyiW2UaHiRO0,11206
+onesecondtrader/strategies/sma_crossover.py,sha256=s2u_uL_D5CrZTACiAbojnrLrLf4jqIPdfOCiNDEIsDA,1119
+onesecondtrader-0.33.0.dist-info/METADATA,sha256=U06iSqkTLBBhLzZCiIl5r-f4-FjpVPF6Qimcgq_kunk,9682
+onesecondtrader-0.33.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+onesecondtrader-0.33.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.33.0.dist-info/RECORD,,

{onesecondtrader-0.31.0.dist-info → onesecondtrader-0.33.0.dist-info}/WHEEL

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