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

onesecondtrader/core/portfolio.py

@@ -1,177 +0,0 @@
-import threading
-
-from onesecondtrader import messaging
-from onesecondtrader.messaging import events
-from onesecondtrader.strategies import base_strategy
-from onesecondtrader.monitoring import console
-from onesecondtrader.core import models
-
-
-class Portfolio:
-    def __init__(self, event_bus: messaging.EventBus | None = None):
-        """
-        Initialize the Portfolio class and subscribe to events.
-        Most importantly, the `symbol_to_strategy` registry is initialized,
-         which keeps track of which symbols are currently assigned to which strategy
-         in order to enforce exclusive symbol ownership.
-
-        Args:
-            event_bus (messaging.EventBus | None): Event bus to use; defaults to
-                 messaging.system_event_bus when None.
-
-        Attributes:
-            self._lock (threading.Lock): Lock for thread-safe operations.
-            self.event_bus (messaging.EventBus): Event bus used for communication
-                 between the trading infrastructure's components.
-            self.symbols_to_strategy (dict[str, base_strategy.Strategy]): Registry of
-                 symbols to strategies.
-        """
-        # ------------------------------------------------------------------------------
-        # INITIALIZE LOCK FOR THREAD-SAFE OPERATIONS
-        self._lock: threading.Lock = threading.Lock()
-
-        # ------------------------------------------------------------------------------
-        # INITIALIZE EVENT BUS AND SUBSCRIBE TO EVENTS
-        self.event_bus: messaging.EventBus = (
-            event_bus if event_bus else messaging.system_event_bus
-        )
-        self.event_bus.subscribe(events.Strategy.SymbolRelease, self.on_symbol_release)
-
-        # ------------------------------------------------------------------------------
-        # INITIALIZE SYMBOLS TO STRATEGY REGISTRY
-        self.symbols_to_strategy: dict[str, base_strategy.Strategy] = {}
-
-    def on_symbol_release(self, event: messaging.events.Base.Event) -> None:
-        """
-        Event handler for symbol release events (`events.Strategy.SymbolRelease`).
-        The symbol is removed from the `symbols_to_strategy` registry.
-
-        Args:
-            event (messaging.events.Base.Event): Symbol release event.
-        """
-        # ------------------------------------------------------------------------------
-        # IGNORE UNRELATED EVENT TYPES
-        if not isinstance(event, events.Strategy.SymbolRelease):
-            return
-
-        # ------------------------------------------------------------------------------
-        # RELEASE SYMBOL FROM STRATEGY
-        symbol = event.symbol
-        with self._lock:
-            if symbol in self.symbols_to_strategy:
-                del self.symbols_to_strategy[symbol]
-                console.logger.info(
-                    f"on_symbol_release: symbol {symbol} released from "
-                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
-                )
-            else:
-                console.logger.warning(
-                    f"on_symbol_release: symbol {symbol} not owned by "
-                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
-                )
-
-    def assign_symbols(
-        self, strategy_instance: base_strategy.Strategy, symbols: list[str]
-    ) -> bool:
-        """
-        Assign a list of symbols to a strategy if no conflicts exist and notify the
-         strategy of the assignment.
-
-        Args:
-            strategy_instance (base_strategy.Strategy): Strategy instance to assign
-                symbols to.
-            symbols (list[str]): List of symbols to assign.
-        """
-        # ------------------------------------------------------------------------------
-        # VALIDATE THAT INSTANCE IS A SUBCLASS OF base_strategy.Strategy
-        if not isinstance(strategy_instance, base_strategy.Strategy):
-            console.logger.error("assign_symbols: strategy must inherit from Strategy")
-            return False
-
-        # ------------------------------------------------------------------------------
-        # CHECK FOR CONFLICTS
-        non_conflicting: list[str] = []
-        conflicting: list[str] = []
-        with self._lock:
-            for symbol in symbols:
-                owner = self.symbols_to_strategy.get(symbol)
-                if owner is None:
-                    non_conflicting.append(symbol)
-                else:
-                    conflicting.append(symbol)
-        if conflicting:
-            console.logger.warning(
-                "assign_symbols: symbols not assigned due to conflicts; "
-                "use Portfolio.assign_symbols(...) after resolving. "
-                f"non_conflicting={non_conflicting}, conflicts={conflicting}"
-            )
-            return False
-        else:
-            # --------------------------------------------------------------------------
-            # ASSIGN SYMBOLS TO REGISTRY
-            for symbol in symbols:
-                self.symbols_to_strategy[symbol] = strategy_instance
-
-            # --------------------------------------------------------------------------
-            # PUBLISH SYMBOL ASSIGNMENT EVENT
-            # noinspection PyArgumentList
-            self.event_bus.publish(
-                events.Strategy.SymbolAssignment(
-                    strategy=strategy_instance,
-                    symbol_list=symbols,
-                )
-            )
-            return True
-
-    def unassign_symbols(
-        self,
-        symbols: list[str],
-        shutdown_mode: models.SymbolShutdownMode = models.SymbolShutdownMode.SOFT,
-    ) -> bool:
-        """
-        Unassign a list of symbols from their owning strategy if all of them have
-         previously been assigned to a strategy.
-        Calling this methods will request the owning strategy to stop trading the symbol
-         in the manner dictated via the `shutdown_mode` argument (default to soft
-         shutdown, i.e. wait for open positions to close naturally and release symbols
-         once they are flat).
-        After the owning strategy has released the symbol, the symbol is unassigned from
-         the portfolio via the `on_symbol_release` event handler.
-
-        Args:
-            symbols (list[str]): List of symbols to unassign.
-            shutdown_mode (models.SymbolShutdownMode): Shutdown mode to use. Defaults
-                to `models.SymbolShutdownMode.SOFT`.
-        """
-        # ------------------------------------------------------------------------------
-        # CHECK THAT SYMBOLS ARE REGISTERED
-        conflicting: list[str] = []
-        with self._lock:
-            for symbol in symbols:
-                if symbol not in self.symbols_to_strategy:
-                    conflicting.append(symbol)
-            if conflicting:
-                console.logger.warning(
-                    "unassign_symbols: symbols not unassigned due to conflicts; "
-                    f"conflicts={conflicting}. "
-                    f"Use Portfolio.unassign_symbols(...) after resolving."
-                )
-                return False
-            else:
-                # ----------------------------------------------------------------------
-                # PUBLISH STOP TRADING SYMBOL EVENT FOR EACH SYMBOL
-                for symbol in symbols:
-                    # noinspection PyArgumentList
-                    self.event_bus.publish(
-                        events.Strategy.StopTradingSymbol(
-                            strategy=self.symbols_to_strategy[symbol],
-                            symbol=symbol,
-                            shutdown_mode=shutdown_mode,
-                        )
-                    )
-                    console.logger.info(
-                        f"unassign_symbols: trading stop for {symbol} trading strategy "
-                        f"{self.symbols_to_strategy[symbol]} requested with shutdown"
-                        f"mode {shutdown_mode.name}"
-                    )
-                return True

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