onesecondtrader 0.16.0__tar.gz → 0.18.0__tar.gz

{onesecondtrader-0.16.0 → onesecondtrader-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.16.0
+Version: 0.18.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.16.0 → onesecondtrader-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.16.0"
+version = "0.18.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.18.0/src/onesecondtrader/core.py

@@ -0,0 +1,147 @@
+"""
+Core module containing the backbone of OneSecondTrader's event-driven architecture.
+"""
+
+import abc
+import dataclasses
+import enum
+import pandas as pd
+import queue
+import threading
+import uuid
+
+from collections import defaultdict
+
+
+class Models:
+    """
+    Namespace for all models.
+    """
+
+    class RecordType(enum.Enum):
+        OHLCV_1S = 32
+        OHLCV_1M = 33
+        OHLCV_1H = 34
+        OHLCV_1D = 35
+
+    class OrderSide(enum.Enum):
+        BUY = enum.auto()
+        SELL = enum.auto()
+
+    class OrderType(enum.Enum):
+        MARKET = enum.auto()
+        LIMIT = enum.auto()
+        STOP = enum.auto()
+        STOP_LIMIT = enum.auto()
+
+
+class Events:
+    """
+    Namespace for all events.
+    """
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class BaseEvent:
+        ts_event: pd.Timestamp = dataclasses.field(
+            default_factory=lambda: pd.Timestamp.now(tz="UTC")
+        )
+
+    # SYSTEM EVENTS
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class SystemShutdown(BaseEvent):
+        pass
+
+    # MARKET EVENTS
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class IncomingBar(BaseEvent):
+        ts_event: pd.Timestamp
+        symbol: str
+        record_type: Models.RecordType
+        open: float
+        high: float
+        low: float
+        close: float
+        volume: int | None = None
+
+    # BROKER REQUEST EVENTS
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class Order(BaseEvent):
+        order_id: uuid.UUID = dataclasses.field(default_factory=lambda: uuid.uuid4())
+        symbol: str
+        order_type: Models.OrderType
+        side: Models.OrderSide
+        quantity: float
+        limit_price: float | None = None
+        stop_price: float | None = None
+
+    # BROKER RESPONSE EVENTS
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class Fill(BaseEvent):
+        fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+        broker_fill_id: str | None = None
+        associated_order_id: uuid.UUID
+        side: Models.OrderSide
+        quantity_filled: float
+        fill_price: float
+        commission: float
+        exchange: str = "SIMULATED"
+
+
+class BaseConsumer(abc.ABC):
+    """
+    Base class for all consumers.
+    """
+
+    def __init__(self) -> None:
+        self._queue: queue.Queue[Events.BaseEvent] = queue.Queue()
+        self._thread = threading.Thread(target=self._consume, daemon=True)
+        self._thread.start()
+
+    @abc.abstractmethod
+    def on_event(self, event: Events.BaseEvent) -> None:
+        pass
+
+    def receive(self, event: Events.BaseEvent) -> None:
+        self._queue.put(event)
+
+    def _consume(self) -> None:
+        while True:
+            event = self._queue.get()
+            if isinstance(event, Events.SystemShutdown):
+                break
+            self.on_event(event)
+
+
+class EventBus:
+    """
+    Event bus for publishing events to the consumers subscribed to them.
+    """
+
+    def __init__(self) -> None:
+        self._subscriptions: defaultdict[type[Events.BaseEvent], list[BaseConsumer]] = (
+            defaultdict(list)
+        )
+        self._lock: threading.Lock = threading.Lock()
+
+    def subscribe(self, subscriber: BaseConsumer, event_type: type[Events.BaseEvent]):
+        with self._lock:
+            if subscriber not in self._subscriptions[event_type]:
+                self._subscriptions[event_type].append(subscriber)
+
+    def unsubscribe(self, subscriber: BaseConsumer):
+        with self._lock:
+            for consumer_list in self._subscriptions.values():
+                if subscriber in consumer_list:
+                    consumer_list.remove(subscriber)
+
+    def publish(self, event: Events.BaseEvent) -> None:
+        with self._lock:
+            consumers = list(self._subscriptions[type(event)])
+        for consumer in consumers:
+            consumer.receive(event)
+
+
+event_bus = EventBus()
+"""
+Global event bus instance.
+"""

{onesecondtrader-0.16.0 → onesecondtrader-0.18.0}/src/onesecondtrader/indicators.py

@@ -8,7 +8,7 @@ import numpy as np
 import threading
 
 from collections import deque
-from onesecondtrader.ontology import Bar
+from onesecondtrader.core import Events
 
 
 class BaseIndicator(abc.ABC):
@@ -26,13 +26,13 @@ class BaseIndicator(abc.ABC):
     def name(self) -> str:
         pass
 
-    def update(self, incoming_bar: Bar) -> None:
+    def update(self, incoming_bar: Events.IncomingBar) -> None:
         _latest_value: float = self._compute_indicator(incoming_bar)
         with self._lock:
             self._history.append(_latest_value)
 
     @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: Bar) -> float:
+    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
         pass
 
     @property
@@ -79,24 +79,28 @@ class SimpleMovingAverage(BaseIndicator):
     def name(self) -> str:
         return f"SMA_{self.period}_{self.input_source.name}"
 
-    def _compute_indicator(self, bar: Bar) -> float:
-        value: float = self._extract_input(bar)
+    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
+        value: float = self._extract_input(incoming_bar)
         self._window.append(value)
         if len(self._window) < self.period:
             return np.nan
         return sum(self._window) / self.period
 
-    def _extract_input(self, bar: Bar) -> float:
+    def _extract_input(self, incoming_bar: Events.IncomingBar) -> float:
         match self.input_source:
             case InputSource.OPEN:
-                return float(bar.open)
+                return incoming_bar.open
             case InputSource.HIGH:
-                return float(bar.high)
+                return incoming_bar.high
             case InputSource.LOW:
-                return float(bar.low)
+                return incoming_bar.low
             case InputSource.CLOSE:
-                return float(bar.close)
+                return incoming_bar.close
             case InputSource.VOLUME:
-                return float(bar.volume)
+                return (
+                    float(incoming_bar.volume)
+                    if incoming_bar.volume is not None
+                    else np.nan
+                )
             case _:
-                return float(bar.close)
+                return incoming_bar.close

onesecondtrader-0.16.0/src/onesecondtrader/ontology.py

@@ -1,18 +0,0 @@
-"""
-Domain-specific data models that are used system-wide.
-"""
-
-import dataclasses
-
-
-@dataclasses.dataclass(slots=True)
-class Bar:
-    """
-    Data model for OHLCV bar data.
-    """
-
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int