onesecondtrader 0.30.0__py3-none-any.whl → 0.32.0__py3-none-any.whl

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/indicators/__init__.py

@@ -5,7 +5,9 @@ __all__ = [
     "Low",
     "Close",
     "Volume",
+    "SimpleMovingAverage",
 ]
 
 from .base import Indicator
 from .bar import Open, High, Low, Close, Volume
+from .averages import SimpleMovingAverage

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

onesecondtrader/models/__init__.py

@@ -1,8 +1,12 @@
 __all__ = [
     "BarPeriod",
+    "InputSource",
     "OrderSide",
     "OrderType",
+    "OrderRecord",
+    "FillRecord",
 ]
 
-from .data import BarPeriod
+from .data import BarPeriod, InputSource
 from .orders import OrderSide, OrderType
+from .records import OrderRecord, FillRecord

onesecondtrader/models/data.py

@@ -8,3 +8,11 @@ class BarPeriod(enum.Enum):
     MINUTE = enum.auto()
     HOUR = enum.auto()
     DAY = enum.auto()
+
+
+class InputSource(enum.Enum):
+    OPEN = enum.auto()
+    HIGH = enum.auto()
+    LOW = enum.auto()
+    CLOSE = enum.auto()
+    VOLUME = enum.auto()

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,5 @@
+__all__ = [
+    "StrategyBase",
+]
+
+from .base import StrategyBase

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(symbol)
+        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(event.symbol)
+            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-0.30.0.dist-info → onesecondtrader-0.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.30.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.30.0.dist-info → onesecondtrader-0.32.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/__init__.py,sha256=edb0kipMTx0p-utX0tc4J8IbhFrZprX200oxhX8LzH4,241
 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
@@ -7,16 +7,20 @@ onesecondtrader/events/bases.py,sha256=g-ykq2jgcitIAueRurUlqAq0jINQwuhSWi_khAniP
 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/indicators/__init__.py,sha256=sGRS3cpN2yLBYws66eVeqY-bAIHg0o6pgFvrkzZtm0Q,170
+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/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=cH5xyniz78MQjM9_-fFdP1ZW6FFLTmayMwQauFO23bU,135
-onesecondtrader/models/data.py,sha256=TqUvTtjpmzTJT8ZdTYnlVoyI7Qck2IsseCazWZxJgD0,173
+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.30.0.dist-info/METADATA,sha256=WBtjr3Eh-kk7ZK4Q7MCF9Dv_UDhJgbGAeMeW_8il5FI,9682
-onesecondtrader-0.30.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.30.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.30.0.dist-info/RECORD,,
+onesecondtrader/models/records.py,sha256=vdCWBtoDQs5R4iB_8_3fXkxWEvoCxOssk9XBnS4l7Vk,599
+onesecondtrader/strategies/__init__.py,sha256=V1xobVVGzKWTORK63vTfuS4a-9_8Qtfcnlek1da7uAM,66
+onesecondtrader/strategies/base.py,sha256=qE78AfPjOC8iWbfWSZfc2uQ2FqKuvBJJ-ce5p-kNAYo,11228
+onesecondtrader-0.32.0.dist-info/METADATA,sha256=3L-rFM2jJ6R54W2AHucu4lGIhMkf1YyyLK67lhu20lI,9682
+onesecondtrader-0.32.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+onesecondtrader-0.32.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.32.0.dist-info/RECORD,,

{onesecondtrader-0.30.0.dist-info → onesecondtrader-0.32.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