onesecondtrader 0.14.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

onesecondtrader/core/models.py

@@ -1,188 +0,0 @@
-from dataclasses import dataclass
-import enum
-
-
-@dataclass(frozen=True, slots=True)
-class Bar:
-    """
-    Class for representing a OHLC(V) bar of market data.
-
-    Attributes:
-        open (float): Open price
-        high (float): High price
-        low (float): Low price
-        close (float): Close price
-        volume (int | None): Volume
-    """
-
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-
-
-class Side(enum.Enum):
-    """
-    Enum for order sides.
-    """
-
-    BUY = enum.auto()
-    SELL = enum.auto()
-
-
-class TimeInForce(enum.Enum):
-    """
-    Order time-in-force specifications.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `DAY` | `enum.auto()` | Valid until end of trading day |
-    | `FOK` | `enum.auto()` | Fill entire order immediately or cancel (Fill-or-Kill) |
-    | `GTC` | `enum.auto()` | Active until explicitly cancelled (Good-Till-Cancelled) |
-    | `GTD` | `enum.auto()` | Active until specified date (Good-Till-Date) |
-    | `IOC` | `enum.auto()` | Execute available quantity immediately, cancel rest (Immediate-or-Cancel) |
-    """
-
-    DAY = enum.auto()
-    FOK = enum.auto()
-    GTC = enum.auto()
-    GTD = enum.auto()
-    IOC = enum.auto()
-
-
-class OrderType(enum.Enum):
-    """
-    Enum for order types.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `MARKET` | `enum.auto()` | Market order |
-    | `LIMIT` | `enum.auto()` | Limit order |
-    | `STOP` | `enum.auto()` | Stop order |
-    | `STOP_LIMIT` | `enum.auto()` | Stop-limit order |
-    """
-
-    MARKET = enum.auto()
-    LIMIT = enum.auto()
-    STOP = enum.auto()
-    STOP_LIMIT = enum.auto()
-
-
-class OrderLifecycleState(enum.Enum):
-    """
-    Enum for order lifecycle states.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `PENDING` | `enum.auto()` | Order has been submitted, but not yet acknowledged by the brokers |
-    | `OPEN` | `enum.auto()` | Order has been acknowledged by the brokers, but not yet filled or cancelled |
-    | `FILLED` | `enum.auto()` | Order has been filled |
-    | `CANCELLED` | `enum.auto()` | Order has been cancelled |
-    """
-
-    PENDING = enum.auto()
-    OPEN = enum.auto()
-    PARTIALLY_FILLED = enum.auto()
-    FILLED = enum.auto()
-    CANCELLED = enum.auto()
-
-
-class OrderRejectionReason(enum.Enum):
-    """
-    Enum for order rejection reasons.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `UNKNOWN` | `enum.auto()` | Unknown reason |
-    | `NEGATIVE_QUANTITY` | `enum.auto()` | Negative quantity |
-    """
-
-    UNKNOWN = enum.auto()
-    NEGATIVE_QUANTITY = enum.auto()
-
-
-class RecordType(enum.Enum):
-    """
-    Enum for Databento record types.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `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})"
-
-
-class XMAMode(enum.Enum):
-    """
-    Enum for moving average modes.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `OPEN` | `enum.auto()` | Open price |
-    | `HIGH` | `enum.auto()` | High price |
-    | `LOW` | `enum.auto()` | Low price |
-    | `CLOSE` | `enum.auto()` | Close price |
-    | `TYPICAL_PRICE` | `enum.auto()` | Typical price ((H+ L + C) / 3) |
-    | `WEIGHTED_CLOSE` | `enum.auto()` | Weighted close price ((H + L + 2*C) / 4) |
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    TYPICAL_PRICE = enum.auto()
-    WEIGHTED_CLOSE = enum.auto()
-
-
-class Position:
-    pass
-
-
-class StrategyShutdownMode(enum.Enum):
-    """
-    Enum for strategy shutdown modes.
-
-    **Attributes:**
-
-    | Enum | Value | Description |
-    |------|-------|-------------|
-    | `SOFT` | `enum.auto()` | Do not open new positions; wait until current positions close naturally |
-    | `HARD` | `enum.auto()` | Close all positions immediately with market orders |
-    """
-
-    SOFT = enum.auto()
-    HARD = enum.auto()

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