onesecondtrader 0.32.0__tar.gz → 0.34.0__tar.gz

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

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

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

@@ -0,0 +1,52 @@
+__all__ = [
+    "BarPeriod",
+    "BarProcessed",
+    "BarReceived",
+    "BrokerBase",
+    "Close",
+    "Datafeed",
+    "FillRecord",
+    "High",
+    "Indicator",
+    "InputSource",
+    "Low",
+    "Open",
+    "OrderFilled",
+    "OrderRecord",
+    "OrderSide",
+    "OrderSubmission",
+    "OrderType",
+    "SimulatedBroker",
+    "SimulatedDatafeed",
+    "SimpleMovingAverage",
+    "SMACrossover",
+    "StrategyBase",
+    "Volume",
+]
+
+from onesecondtrader.brokers import BrokerBase, SimulatedBroker
+from onesecondtrader.datafeeds import Datafeed, SimulatedDatafeed
+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-0.34.0/src/onesecondtrader/datafeeds/__init__.py

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

onesecondtrader-0.34.0/src/onesecondtrader/datafeeds/base.py

@@ -0,0 +1,19 @@
+import abc
+
+from onesecondtrader import events, messaging, models
+
+
+class Datafeed(abc.ABC):
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        self._event_bus = event_bus
+
+    def _publish(self, event: events.EventBase) -> None:
+        self._event_bus.publish(event)
+
+    @abc.abstractmethod
+    def stream(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        pass
+
+    @abc.abstractmethod
+    def shutdown(self) -> None:
+        pass

onesecondtrader-0.34.0/src/onesecondtrader/datafeeds/simulated.py

@@ -0,0 +1,99 @@
+import pathlib
+import threading
+
+import pandas as pd
+
+from onesecondtrader import events, messaging, models
+from .base import Datafeed
+
+_RTYPE_MAP = {
+    models.BarPeriod.SECOND: 32,
+    models.BarPeriod.MINUTE: 33,
+    models.BarPeriod.HOUR: 34,
+    models.BarPeriod.DAY: 35,
+}
+
+
+class SimulatedDatafeed(Datafeed):
+    csv_path: str = ""
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        super().__init__(event_bus)
+        self._thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+
+    def stream(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        csv_path = pathlib.Path(self.csv_path)
+        if self._thread and self._thread.is_alive():
+            raise RuntimeError("Already streaming")
+        if not csv_path.exists():
+            raise FileNotFoundError(f"CSV file not found: {csv_path}")
+        if not symbols:
+            raise ValueError("symbols list cannot be empty")
+
+        self._stop_event.clear()
+        self._thread = threading.Thread(
+            target=self._stream,
+            args=(symbols, bar_period),
+            name=self.__class__.__name__,
+            daemon=False,
+        )
+        self._thread.start()
+
+    def wait(self) -> None:
+        if self._thread:
+            self._thread.join()
+
+    def shutdown(self) -> None:
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+
+    def _stream(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        symbols_set = set(symbols)
+        rtype = _RTYPE_MAP[bar_period]
+
+        for chunk in pd.read_csv(
+            self.csv_path,
+            usecols=[
+                "ts_event",
+                "rtype",
+                "open",
+                "high",
+                "low",
+                "close",
+                "volume",
+                "symbol",
+            ],
+            dtype={
+                "ts_event": int,
+                "rtype": int,
+                "open": int,
+                "high": int,
+                "low": int,
+                "close": int,
+                "volume": int,
+                "symbol": str,
+            },
+            chunksize=10_000,
+        ):
+            for row in chunk.itertuples():
+                if self._stop_event.is_set():
+                    return
+
+                if row.symbol not in symbols_set or row.rtype != rtype:
+                    continue
+
+                self._publish(
+                    events.BarReceived(
+                        ts_event=pd.Timestamp(row.ts_event, unit="ns", tz="UTC"),
+                        symbol=row.symbol,
+                        bar_period=bar_period,
+                        open=row.open / 1e9,
+                        high=row.high / 1e9,
+                        low=row.low / 1e9,
+                        close=row.close / 1e9,
+                        volume=row.volume,
+                    )
+                )
+                self._event_bus.wait_until_system_idle()

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

@@ -0,0 +1,60 @@
+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))
+        self._current_symbol: str = ""
+        self._history_data: dict[str, collections.deque[float]] = {}
+        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
+        self._current_symbol = symbol
+        value = self._compute_indicator(incoming_bar)
+        with self._lock:
+            if symbol not in self._history_data:
+                self._history_data[symbol] = collections.deque(maxlen=self._max_history)
+            self._history_data[symbol].append(value)
+
+    @property
+    def latest(self) -> float:
+        with self._lock:
+            h = self._history_data.get(self._current_symbol, collections.deque())
+            return h[-1] if h else np.nan
+
+    @property
+    def history(self) -> collections.deque[float]:
+        with self._lock:
+            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-0.32.0 → onesecondtrader-0.34.0}/src/onesecondtrader/strategies/__init__.py

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

{onesecondtrader-0.32.0 → onesecondtrader-0.34.0}/src/onesecondtrader/strategies/base.py

@@ -39,7 +39,7 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
         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)
+        # 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()),
@@ -195,7 +195,7 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
         ohlcv_names = {"OPEN", "HIGH", "LOW", "CLOSE", "VOLUME"}
 
         indicator_values = {
-            f"{ind.plot_at:02d}_{ind.name}": ind.latest(event.symbol)
+            f"{ind.plot_at:02d}_{ind.name}": ind.latest
             for ind in self._indicators
             if ind.name not in ohlcv_names
         }

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

@@ -1,5 +0,0 @@
-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/indicators/base.py

@@ -1,50 +0,0 @@
-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