onesecondtrader 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

onesecondtrader/datafeeds/base_datafeed.py

@@ -1,54 +0,0 @@
-"""
-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 | None = None):
-        self.event_bus: messaging.EventBus = (
-            event_bus if event_bus else messaging.system_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/datafeeds/csv_datafeed.py

@@ -1,297 +0,0 @@
-"""
-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/indicators/base_indicator.py

@@ -1,136 +0,0 @@
-"""
-This module provides the base class for all indicators.
-"""
-
-import abc
-import collections
-import threading
-
-import numpy as np
-from onesecondtrader.core import models
-from onesecondtrader.monitoring import console
-
-
-class BaseIndicator(abc.ABC):
-    """
-    Base class for all indicators.
-
-    If new market data is received, the indicator is updated by calling the
-    `update(incoming_bar)` method.
-    When programming a new indicator, only the `name` property and the
-    `_compute_indicator()` method need to be implemented.
-
-    Examples:
-        >>> from onesecondtrader.indicators import base_indicator
-        >>> from onesecondtrader.core import models
-        >>> class DummyCloseIndicator(base_indicator.BaseIndicator):
-        ...     @property
-        ...     def name(self) -> str:
-        ...         return "dummy_close_indicator"
-        ...     def _compute_indicator(self, incoming_bar: models.Bar):
-        ...         return incoming_bar.close
-        ...
-        >>> dummy_close_indicator = DummyCloseIndicator(max_history=10)
-        >>> incoming_bar = models.Bar(
-        ...     open=100.0, high=101.0, low=99.0, close=100.5, volume=10000
-        ... )
-        >>> dummy_close_indicator.update(incoming_bar)
-        >>> dummy_close_indicator[0]
-        100.5
-        >>> dummy_close_indicator[-1]
-        nan
-        >>> next_incoming_bar = models.Bar(
-        ...     open=100.0, high=101.0, low=99.0, close=101.0, volume=10000
-        ... )
-        >>> dummy_close_indicator.update(next_incoming_bar)
-        >>> dummy_close_indicator[0]
-        101.0
-        >>> dummy_close_indicator[-1]
-        100.5
-    """
-
-    def __init__(self, max_history: int = 100) -> None:
-        """
-        Initialize the indicator with a maximum lookback history length.
-
-        Args:
-            max_history (int): Maximum lookback history length as number of periods.
-            Defaults to 100.
-
-        Attributes:
-            self._lock (threading.Lock): Lock to protect concurrent access to the
-                indicator's state.
-            self._history (collections.deque): Deque to store the lookback history.
-        """
-        if max_history < 1:
-            console.logger.warning(
-                f"max_history must be >= 1, got {max_history}; defaulting to 1"
-            )
-            max_history = 1
-        self._lock: threading.Lock = threading.Lock()
-
-        self._history: collections.deque[float] = collections.deque(maxlen=max_history)
-
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        """
-        Name of the indicator.
-        This property must be implemented by subclasses.
-
-        Returns:
-            str: Name of the indicator.
-        """
-        pass
-
-    @property
-    def latest(self) -> float:
-        """
-        The latest (most recent) indicator value.
-
-        Equivalent to self[0]. Returns numpy.nan when no value is available yet.
-        """
-        return self[0]
-
-    def update(self, incoming_bar: models.Bar) -> None:
-        """
-        Updates the indicator based on an incoming closed bar by calling
-        `self._compute_indicator()`.
-        """
-        new_value = self._compute_indicator(incoming_bar)
-        with self._lock:
-            self._history.append(new_value)
-
-    @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: models.Bar) -> float:
-        """
-        Computes the new indicator value based on an incoming closed bar.
-        This method must be implemented by subclasses.
-        """
-        pass
-
-    def __getitem__(self, index: int) -> float:
-        """
-        Return the indicator value at the given index with tolerant indexing.
-
-        Indexing rules:
-
-        - `0` returns the current (most recent) value
-        - `-1` returns the previous value, `-2` two periods back, and so on
-        - For convenience, a positive `k` behaves like `-k` (e.g., `1 == -1`,
-          `2 == -2`)
-        - Out-of-range indices return `np.nan` instead of raising an `IndexError`.
-        """
-        normalized: int
-        if index == 0:
-            normalized = -1
-        elif index > 0:
-            normalized = -(index + 1)
-        else:
-            normalized = index - 1
-
-        with self._lock:
-            try:
-                return self._history[normalized]
-            except IndexError:
-                return np.nan

onesecondtrader/indicators/moving_averages.py

@@ -1,132 +0,0 @@
-"""
-This module provides various moving average indicators.
-"""
-
-import numpy as np
-import collections
-from onesecondtrader.indicators import base_indicator
-from onesecondtrader.core import models
-from onesecondtrader.monitoring import console
-
-
-class SimpleMovingAverage(base_indicator.BaseIndicator):
-    """
-    Simple Moving Average (SMA) indicator for different OHLC-data related time series,
-     the possible modes for the SMA calculation are indicated in the
-     `core.models.XMAMode` enum (currently: `open`, `high`, `low`, `close`,
-     `typical_price`, `weighted close`).
-
-    Examples:
-        >>> from onesecondtrader.indicators import moving_averages
-        >>> from onesecondtrader.core import models
-        >>> sma = moving_averages.SimpleMovingAverage(
-        ...     period=3, mode=models.XMAMode.CLOSE
-        ... )
-        >>> bar1 = models.Bar(
-        ...     open=100.0, high=101.0, low=99.0, close=100.0, volume=1000
-        ... )
-        >>> sma.update(bar1)
-        >>> import numpy as np
-        >>> np.isnan(sma.latest)
-        True
-        >>> bar2 = models.Bar(
-        ...     open=100.0, high=102.0, low=100.0, close=101.0, volume=1500
-        ... )
-        >>> sma.update(bar2)
-        >>> np.isnan(sma.latest)
-        True
-        >>> bar3 = models.Bar(
-        ...     open=101.0, high=103.0, low=101.0, close=102.0, volume=2000
-        ... )
-        >>> sma.update(bar3)
-        >>> np.isnan(sma.latest)
-        False
-        >>> sma.latest
-        101.0
-    """
-
-    def __init__(
-        self,
-        period: int,
-        mode: models.XMAMode = models.XMAMode.CLOSE,
-        max_history: int = 100,
-    ) -> None:
-        """
-        Initialize the indicator with a period and a mode.
-
-        Args:
-            period (int): Period of the moving average. Will be set to 1 if < 1.
-            mode (models.XMAMode): Mode of the moving average. Defaults to `CLOSE`.
-            max_history (int): Maximum lookback history length. Defaults to 100.
-
-        Attributes:
-            self.period (int): Period of the moving average.
-            self.mode (models.XMAMode): Mode of the moving average.
-        """
-        if period < 1:
-            console.logger.warning(
-                f"Period must be >= 1, got {period}; defaulting to 1"
-            )
-            period = 1
-
-        super().__init__(max_history=max_history)
-        self.period: int = period
-        self.mode: models.XMAMode = mode
-        self._window: collections.deque[float] = collections.deque(maxlen=self.period)
-
-    @property
-    def name(self) -> str:
-        return f"SMA_{self.period}_{self.mode.name}"
-
-    def _compute_indicator(self, incoming_bar: models.Bar) -> float:
-        """
-        Compute the specified simple moving average based on the incoming bar.
-
-        Args:
-            incoming_bar (models.Bar): Incoming bar with OHLCV data.
-
-        Returns:
-            float: Simple moving average value, or np.nan if insufficient data or
-                errors occur.
-        """
-        try:
-            mode = self.mode
-            if mode is models.XMAMode.OPEN:
-                current_value = incoming_bar.open
-            elif mode is models.XMAMode.HIGH:
-                current_value = incoming_bar.high
-            elif mode is models.XMAMode.LOW:
-                current_value = incoming_bar.low
-            elif mode is models.XMAMode.CLOSE:
-                current_value = incoming_bar.close
-            elif mode is models.XMAMode.TYPICAL_PRICE:
-                current_value = (
-                    incoming_bar.high + incoming_bar.low + incoming_bar.close
-                ) / 3.0
-            elif mode is models.XMAMode.WEIGHTED_CLOSE:
-                current_value = (
-                    incoming_bar.high + incoming_bar.low + 2.0 * incoming_bar.close
-                ) / 4.0
-            else:
-                console.logger.warning(
-                    f"Unsupported XMAMode: {mode}; using close price"
-                )
-                current_value = incoming_bar.close
-
-            if not np.isfinite(current_value):
-                console.logger.warning(
-                    f"Invalid value extracted: {current_value} (mode={mode.name}); "
-                    f"using np.nan"
-                )
-                return np.nan
-
-            with self._lock:
-                self._window.append(current_value)
-                if len(self._window) < self.period:
-                    return np.nan
-                sma_value = sum(self._window) / self.period
-            return sma_value
-
-        except Exception as e:
-            console.logger.warning(f"SMA calculation failed: {e}; returning np.nan")
-            return np.nan

onesecondtrader/messaging/__init__.py

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