onesecondtrader 0.10.1__tar.gz → 0.11.0__tar.gz

{onesecondtrader-0.10.1 → onesecondtrader-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: onesecondtrader
-Version: 0.10.1
+Version: 0.11.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 Author: Nils P. Kujath
 Author-email: 63961429+NilsKujath@users.noreply.github.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: pandas (>=2.3.1,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 # OneSecondTrader

{onesecondtrader-0.10.1 → onesecondtrader-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.10.1"
+version = "0.11.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"}
@@ -9,6 +9,7 @@ readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "pandas (>=2.3.1,<3.0.0)",
+    "python-dotenv (>=1.0.0,<2.0.0)",
 ]
 
 [tool.poetry]

{onesecondtrader-0.10.1 → onesecondtrader-0.11.0}/src/onesecondtrader/core/models.py

@@ -32,14 +32,14 @@ class Bar:
         high (float): High price
         low (float): Low price
         close (float): Close price
-        volume (float): Volume
+        volume (int | None): Volume
     """
 
     open: float
     high: float
     low: float
     close: float
-    volume: float | None = None
+    volume: int | None = None
 
 
 class Side(enum.Enum):
@@ -133,27 +133,35 @@ class OrderRejectionReason(enum.Enum):
     NEGATIVE_QUANTITY = enum.auto()
 
 
-class TimeFrame(enum.Enum):
+class RecordType(enum.Enum):
     """
-    Enum for timeframes.
+    Enum for Databento record types.
 
     **Attributes:**
 
     | Enum | Value | Description |
     |------|-------|-------------|
-    | `SECOND` | `enum.auto()` | 1 second |
-    | `MINUTE` | `enum.auto()` | 1 minute |
-    | `HOUR` | `enum.auto()` | 1 hour |
-    | `DAY` | `enum.auto()` | 1 day |
-    | `WEEK` | `enum.auto()` | 1 week |
-    | `MONTH` | `enum.auto()` | 1 month |
-    | `YEAR` | `enum.auto()` | 1 year
-    """
-
-    SECOND = enum.auto()
-    MINUTE = enum.auto()
-    HOUR = enum.auto()
-    DAY = enum.auto()
-    WEEK = enum.auto()
-    MONTH = enum.auto()
-    YEAR = enum.auto()
+    | `OHLCV_1S` | `32` | 1-second bars |
+    | `OHLCV_1M` | `33` | 1-minute bars |
+    | `OHLCV_1H` | `34` | 1-hour bars |
+    | `OHLCV_1D` | `35` | 1-day bars |
+    """
+
+    OHLCV_1S = 32
+    OHLCV_1M = 33
+    OHLCV_1H = 34
+    OHLCV_1D = 35
+
+    @classmethod
+    def to_string(cls, rtype: int) -> str:
+        match rtype:
+            case cls.OHLCV_1S.value:
+                return "1-second bars"
+            case cls.OHLCV_1M.value:
+                return "1-minute bars"
+            case cls.OHLCV_1H.value:
+                return "1-hour bars"
+            case cls.OHLCV_1D.value:
+                return "daily bars"
+            case _:
+                return f"unknown ({rtype})"

onesecondtrader-0.11.0/src/onesecondtrader/datafeeds/__init__.py

@@ -0,0 +1,2 @@
+from .base_datafeed import BaseDatafeed as BaseDatafeed
+from .csv_datafeed import CSVDatafeed as CSVDatafeed

onesecondtrader-0.11.0/src/onesecondtrader/datafeeds/base_datafeed.py

@@ -0,0 +1,58 @@
+"""
+This module provides the base class for all datafeeds.
+"""
+
+import abc
+from onesecondtrader import messaging
+from onesecondtrader.core import models
+
+
+class BaseDatafeed(abc.ABC):
+    """
+    Base class for all datafeeds.
+    """
+
+    def __init__(self, event_bus: messaging.EventBus):
+        """
+        Initialize the datafeed with an event bus.
+
+        Args:
+            event_bus (messaging.EventBus): Event bus to publish market data events to.
+        """
+        self.event_bus: messaging.EventBus = event_bus
+
+    @abc.abstractmethod
+    def connect(self):
+        """
+        Connect to the datafeed.
+        """
+        pass
+
+    @abc.abstractmethod
+    def watch(self, symbols: list[tuple[str, models.RecordType]]):
+        """
+        Start watching symbols.
+
+        Args:
+            symbols (list[tuple[str, models.TimeFrame]]): List of symbols to watch with
+                their respective timeframes.
+        """
+        pass
+
+    @abc.abstractmethod
+    def unwatch(self, symbols: list[tuple[str, models.RecordType]]):
+        """
+        Stop watching symbols.
+
+        Args:
+            symbols (list[tuple[str, models.TimeFrame]]): List of symbols to stop
+                watching with their respective timeframes.
+        """
+        pass
+
+    @abc.abstractmethod
+    def disconnect(self):
+        """
+        Disconnect from the datafeed.
+        """
+        pass

onesecondtrader-0.11.0/src/onesecondtrader/datafeeds/csv_datafeed.py

@@ -0,0 +1,297 @@
+"""
+This module provides a CSV-based simulated live datafeed.
+"""
+
+import os
+import pandas as pd
+import threading
+import time
+from pathlib import Path
+from dotenv import load_dotenv
+from onesecondtrader.messaging import events, eventbus
+from onesecondtrader.core import models
+from onesecondtrader.monitoring import console
+from onesecondtrader.datafeeds import base_datafeed
+from pandas.io.parsers.readers import TextFileReader
+
+
+class CSVDatafeed(base_datafeed.BaseDatafeed):
+    """
+    CSV-based simulated live datafeed.
+
+    Only one instance of any BaseDatafeed subclass can exist at a time.
+    """
+
+    _instance = None
+
+    def __init__(
+        self,
+        event_bus: eventbus.EventBus,
+        csv_path: str | Path | None = None,
+        streaming_delay: float | None = None,
+    ):
+        """
+        Initialize CSV datafeed.
+
+        Args:
+            event_bus: Event bus used to publish market data events.
+            csv_path: Optional path to CSV file. Overrides CSV_PATH env var.
+            streaming_delay: Optional delay in seconds between processing rows.
+                Overrides CSV_STREAMING_DELAY env var.
+
+        Attributes:
+            self.csv_path (Path | None): Path to CSV file.
+            self.data_iterator (TextFileReader | None): Iterator for reading CSV.
+            self._watched_symbols (set[tuple[str, models.RecordType]]): Set of
+                symbols and record types currently being watched.
+            self._streaming_thread (threading.Thread | None): Background thread
+                for streaming data.
+            self._symbols_lock (threading.Lock): Lock to protect _watched_symbols
+                from concurrent access.
+            self._streaming_delay (float): Delay in seconds between processing
+                CSV rows (from CSV_STREAMING_DELAY env var, set in connect()).
+            self._init_csv_path (str | Path | None): CSV path provided during
+                initialization.
+            self._init_streaming_delay (float | None): Streaming delay provided
+                during initialization.
+        """
+        if CSVDatafeed._instance is not None:
+            console.logger.warning(
+                f"Only one BaseDatafeed instance allowed. "
+                f"Current: {type(CSVDatafeed._instance).__name__}. "
+                f"Initialization failed."
+            )
+            return
+
+        super().__init__(event_bus)
+        CSVDatafeed._instance = self
+
+        self.csv_path: Path | None = None
+        self.data_iterator: TextFileReader | None = None
+        self._watched_symbols: set[tuple[str, models.RecordType]] = set()
+        self._stop_event = threading.Event()
+        self._streaming_thread: threading.Thread | None = None
+        self._symbols_lock: threading.Lock = threading.Lock()
+        self._streaming_delay: float = 0.0
+
+        self._init_csv_path: str | Path | None = csv_path
+        self._init_streaming_delay: float | None = streaming_delay
+
+    def connect(self):
+        """
+        Connect to CSV file specified in .env file (CSV_PATH variable) and
+        create data iterator.
+        """
+        load_dotenv()
+
+        if self._init_csv_path is not None:
+            csv_path_str = str(self._init_csv_path)
+            console.logger.info(f"Using CSV path from initialization: {csv_path_str}")
+        else:
+            csv_path_str = os.getenv("CSV_PATH")
+            if not csv_path_str:
+                console.logger.error(
+                    "CSV_PATH not found in environment variables and not "
+                    "provided in __init__. Either set CSV_PATH in .env file "
+                    "or pass csv_path to CSVDatafeed()"
+                )
+                return False
+
+        if self._init_streaming_delay is not None:
+            self._streaming_delay = self._init_streaming_delay
+            if self._streaming_delay < 0:
+                console.logger.warning(
+                    f"Streaming delay cannot be negative "
+                    f"({self._streaming_delay}), using default 0.0"
+                )
+                self._streaming_delay = 0.0
+            else:
+                console.logger.info(
+                    f"CSV streaming delay set from initialization: "
+                    f"{self._streaming_delay} seconds"
+                )
+        else:
+            streaming_delay_str = os.getenv("CSV_STREAMING_DELAY", "0.0")
+            try:
+                self._streaming_delay = float(streaming_delay_str)
+                if self._streaming_delay < 0:
+                    console.logger.warning(
+                        f"CSV_STREAMING_DELAY cannot be negative "
+                        f"({self._streaming_delay}), using default 0.0"
+                    )
+                    self._streaming_delay = 0.0
+                else:
+                    console.logger.info(
+                        f"CSV streaming delay set from environment: "
+                        f"{self._streaming_delay} seconds"
+                    )
+            except ValueError:
+                console.logger.error(
+                    f"Invalid CSV_STREAMING_DELAY value "
+                    f"'{streaming_delay_str}', must be a number. "
+                    f"Using default 0.0"
+                )
+                self._streaming_delay = 0.0
+
+        self.csv_path = Path(csv_path_str)
+
+        try:
+            self.data_iterator = 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,
+                },
+                iterator=True,
+                chunksize=1,
+            )
+            console.logger.info(f"CSV datafeed connected to: {self.csv_path}")
+            self._stop_event.clear()
+            return True
+
+        except Exception as e:
+            console.logger.error(f"Failed to connect to CSV file {self.csv_path}: {e}")
+            return False
+
+    def watch(self, symbols):
+        """
+        Start streaming data for specified symbols.
+        Can be called multiple times to add more symbols.
+
+        Args:
+            symbols (list[tuple[str, models.RecordType]]): List of symbols to
+                watch with their respective record types.
+        """
+        if not self.data_iterator:
+            console.logger.error("Not connected. Call connect() first.")
+            return
+
+        with self._symbols_lock:
+            new_symbols = set(symbols) - self._watched_symbols
+            already_watched = set(symbols) & self._watched_symbols
+
+            self._watched_symbols.update(new_symbols)
+
+            if new_symbols:
+                console.logger.info(f"Added new symbols: {new_symbols}")
+            if already_watched:
+                console.logger.info(f"Already watching: {already_watched}")
+            console.logger.info(
+                f"Currently watching: {len(self._watched_symbols)} symbols"
+            )
+
+        if self._streaming_thread is None or not self._streaming_thread.is_alive():
+            self._streaming_thread = threading.Thread(
+                target=self._stream, name="CSVDatafeedStreaming", daemon=True
+            )
+            self._streaming_thread.start()
+            console.logger.info("Started CSV streaming thread")
+
+    def _stream(self):
+        """Internal method that runs in background thread to stream CSV data."""
+        console.logger.info("CSV streaming thread started")
+
+        should_delay = self._streaming_delay > 0
+        delay_time = self._streaming_delay
+
+        while not self._stop_event.is_set():
+            try:
+                chunk = next(self.data_iterator)
+                row = chunk.iloc[0]
+
+                symbol = row["symbol"]
+                rtype = row["rtype"]
+
+                with self._symbols_lock:
+                    symbol_key = (symbol, models.RecordType(rtype))
+                    if symbol_key not in self._watched_symbols:
+                        continue
+
+                bar_event = events.Market.IncomingBar(
+                    ts_event=pd.Timestamp(row["ts_event"], unit="ns", tz="UTC"),
+                    symbol=symbol,
+                    bar=models.Bar(
+                        open=row["open"] / 1e9,
+                        high=row["high"] / 1e9,
+                        low=row["low"] / 1e9,
+                        close=row["close"] / 1e9,
+                        volume=int(row["volume"]),
+                    ),
+                )
+
+                self.event_bus.publish(bar_event)
+
+                if should_delay:
+                    time.sleep(delay_time)
+
+            except StopIteration:
+                console.logger.info("CSV datafeed reached end of file")
+                break
+            except ValueError as e:
+                console.logger.warning(f"Invalid rtype {row['rtype']} in CSV data: {e}")
+                continue
+            except Exception as e:
+                console.logger.error(f"CSV datafeed error reading data: {e}")
+                break
+
+        console.logger.info("CSV streaming thread stopped")
+
+    def unwatch(self, symbols):
+        """
+        Stop watching specific symbols.
+
+        Args:
+            symbols (list[tuple[str, models.RecordType]]): List of symbols to
+                stop watching.
+        """
+        with self._symbols_lock:
+            for symbol in symbols:
+                self._watched_symbols.discard(symbol)
+
+            console.logger.info(f"Stopped watching symbols: {symbols}")
+            console.logger.info(f"Still watching: {self._watched_symbols}")
+
+    def disconnect(self):
+        """
+        Disconnect from CSV datafeed.
+        """
+        self._stop_event.set()
+
+        if self._streaming_thread and self._streaming_thread.is_alive():
+            console.logger.info("Waiting for streaming thread to stop...")
+            self._streaming_thread.join(timeout=5.0)
+            if self._streaming_thread.is_alive():
+                console.logger.warning("Streaming thread did not stop within timeout")
+
+        with self._symbols_lock:
+            self._watched_symbols.clear()
+
+        if self.data_iterator is not None:
+            try:
+                self.data_iterator.close()
+                console.logger.info("CSV iterator closed successfully")
+            except Exception as e:
+                console.logger.warning(f"Error closing CSV iterator: {e}")
+            finally:
+                self.data_iterator = None
+
+        self.csv_path = None
+        self._streaming_thread = None
+
+        CSVDatafeed._instance = None

onesecondtrader-0.11.0/src/onesecondtrader/messaging/__init__.py

@@ -0,0 +1,8 @@
+from .eventbus import EventBus as EventBus
+from .events import (
+    Base as Base,
+    Market as Market,
+    Request as Request,
+    Response as Response,
+    System as System,
+)

onesecondtrader-0.10.1/src/onesecondtrader/datafeeds/base_datafeed.py

@@ -1,255 +0,0 @@
-"""
-This module provides the base class for all datafeeds.
-"""
-
-import abc
-import threading
-from onesecondtrader.messaging import eventbus
-from onesecondtrader.core import models
-from onesecondtrader.monitoring import console
-
-
-class BaseDatafeed(abc.ABC):
-    """
-    Base class for all datafeeds.
-    """
-
-    def __init__(self, event_bus: eventbus.EventBus) -> None:
-        """
-        Initialize the datafeed with the provided event bus.
-
-        Args:
-            event_bus: The event bus to publish events to.
-
-        Attributes:
-            self.event_bus: The event bus to publish events to.
-            self._lock: Lock for thread safety.
-            self._is_connected: Flag indicating if the datafeed is connected.
-            self._watched_symbols: Set of symbols currently being watched.
-        """
-        self.event_bus = event_bus
-        self._lock = threading.Lock()
-        self._is_connected = False
-        self._watched_symbols: set[tuple[str, models.TimeFrame]] = set()
-
-    def connect(self) -> bool:
-        """
-        Connect to the datafeed.
-
-        Returns:
-            bool: True if connection successful, False otherwise.
-        """
-        with self._lock:
-            if self._is_connected:
-                console.logger.warning(f"{self.__class__.__name__} already connected")
-                return True
-
-            console.logger.info(f"Connecting to {self.__class__.__name__}...")
-            try:
-                success = self._connect()
-                if success:
-                    self._is_connected = True
-                    console.logger.info(
-                        f"Successfully connected to {self.__class__.__name__}"
-                    )
-                    return True
-                else:
-                    console.logger.error(
-                        f"Failed to connect to {self.__class__.__name__}"
-                    )
-                    return False
-            except Exception as e:
-                console.logger.error(
-                    f"Connection failed for {self.__class__.__name__}: {e}"
-                )
-                return False
-
-    @abc.abstractmethod
-    def _connect(self) -> bool:
-        """
-        Implement connection logic for the specific datafeed.
-
-        Returns:
-            bool: True if connection successful, False otherwise.
-        """
-        pass
-
-    def disconnect(self) -> bool:
-        """
-        Disconnect from the datafeed.
-
-        Returns:
-            bool: True if disconnection successful, False otherwise.
-        """
-        with self._lock:
-            if not self._is_connected:
-                console.logger.warning(
-                    f"{self.__class__.__name__} already disconnected"
-                )
-                return True
-
-            console.logger.info(f"Disconnecting from {self.__class__.__name__}...")
-            try:
-                success = self._disconnect()
-                if success:
-                    self._is_connected = False
-                    self._watched_symbols.clear()
-                    console.logger.info(
-                        f"Successfully disconnected from {self.__class__.__name__}"
-                    )
-                    return True
-                else:
-                    console.logger.error(
-                        f"Failed to disconnect from {self.__class__.__name__}"
-                    )
-                    return False
-            except Exception as e:
-                console.logger.error(
-                    f"Disconnection failed for {self.__class__.__name__}: {e}"
-                )
-                self._is_connected = False
-                self._watched_symbols.clear()
-                return False
-
-    @abc.abstractmethod
-    def _disconnect(self) -> bool:
-        """
-        Implement disconnection logic for the specific datafeed.
-
-        Returns:
-            bool: True if disconnection successful, False otherwise.
-        """
-        pass
-
-    def watch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
-        """
-        Start watching market data for the specified symbols and timeframes.
-
-        Args:
-            symbols: List of (symbol, timeframe) tuples to start watching.
-
-        Returns:
-            bool: True if watching started successfully, False otherwise.
-        """
-        if not symbols:
-            console.logger.warning("No symbols provided for watching")
-            return True
-
-        with self._lock:
-            if not self._is_connected:
-                console.logger.error("Cannot start watching: datafeed not connected")
-                return False
-
-            new_symbols = set(symbols) - self._watched_symbols
-            if not new_symbols:
-                console.logger.info("All requested symbols are already being watched")
-                return True
-
-            try:
-                success = self._watch(list(new_symbols))
-                if success:
-                    self._watched_symbols.update(new_symbols)
-                    console.logger.info(
-                        f"Successfully started watching {len(new_symbols)} symbols"
-                    )
-                    return True
-                else:
-                    console.logger.error("Failed to start watching symbols")
-                    return False
-            except Exception as e:
-                console.logger.error(f"Exception while starting watching: {e}")
-                return False
-
-    @abc.abstractmethod
-    def _watch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
-        """
-        Implement watching startup logic for the specific datafeed.
-
-        Args:
-            symbols: List of (symbol, timeframe) tuples to start watching.
-                    These are guaranteed to be new symbols not already being watched.
-
-        Returns:
-            bool: True if watching started successfully, False otherwise.
-        """
-        pass
-
-    def unwatch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
-        """
-        Stop watching market data for the specified symbols and timeframes.
-
-        Args:
-            symbols: List of (symbol, timeframe) tuples to stop watching.
-
-        Returns:
-            bool: True if unwatching stopped successfully, False otherwise.
-        """
-        if not symbols:
-            console.logger.warning("No symbols provided for unwatching")
-            return True
-
-        with self._lock:
-            if not self._is_connected:
-                console.logger.warning(
-                    "Datafeed not connected, but removing symbols from tracking"
-                )
-                self._watched_symbols.difference_update(symbols)
-                return True
-
-            symbols_to_stop = set(symbols) & self._watched_symbols
-            if not symbols_to_stop:
-                console.logger.info(
-                    "None of the requested symbols are currently being watched"
-                )
-                return True
-
-            console.logger.info(f"Unwatching {len(symbols_to_stop)} symbols")
-            try:
-                success = self._unwatch(list(symbols_to_stop))
-                if success:
-                    self._watched_symbols.difference_update(symbols_to_stop)
-                    console.logger.info(
-                        f"Successfully unwatched {len(symbols_to_stop)} symbols"
-                    )
-                    return True
-                else:
-                    console.logger.error("Failed to unwatch symbols")
-                    return False
-            except Exception as e:
-                console.logger.error(f"Exception while unwatching: {e}")
-                self._watched_symbols.difference_update(symbols_to_stop)
-                return False
-
-    @abc.abstractmethod
-    def _unwatch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
-        """
-        Implement unwatching logic for the specific datafeed.
-
-        Args:
-            symbols: List of (symbol, timeframe) tuples to stop watching.
-                    These are guaranteed to be symbols currently being watched.
-
-        Returns:
-            bool: True if unwatching stopped successfully, False otherwise.
-        """
-        pass
-
-    def is_connected(self) -> bool:
-        """
-        Check if the datafeed is currently connected.
-
-        Returns:
-            bool: True if connected, False otherwise.
-        """
-        with self._lock:
-            return self._is_connected
-
-    def get_watched_symbols(self) -> set[tuple[str, models.TimeFrame]]:
-        """
-        Get the set of currently watched symbols and timeframes.
-
-        Returns:
-            set: Set of (symbol, timeframe) tuples currently being watched.
-        """
-        with self._lock:
-            return self._watched_symbols.copy()