onesecondtrader 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

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/datafeeds/base_datafeed.py

@@ -3,10 +3,8 @@ This module provides the base class for all datafeeds.
 """
 
 import abc
-import threading
-from onesecondtrader.messaging import eventbus
+from onesecondtrader import messaging
 from onesecondtrader.core import models
-from onesecondtrader.monitoring import console
 
 
 class BaseDatafeed(abc.ABC):
@@ -14,242 +12,47 @@ class BaseDatafeed(abc.ABC):
     Base class for all datafeeds.
     """
 
-    def __init__(self, event_bus: eventbus.EventBus) -> None:
+    def __init__(self, event_bus: messaging.EventBus):
         """
-        Initialize the datafeed with the provided event bus.
+        Initialize the datafeed with an 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.
+            event_bus (messaging.EventBus): Event bus to publish market data events to.
         """
-        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
+        self.event_bus: messaging.EventBus = event_bus
 
     @abc.abstractmethod
-    def _connect(self) -> bool:
+    def connect(self):
         """
-        Implement connection logic for the specific datafeed.
-
-        Returns:
-            bool: True if connection successful, False otherwise.
+        Connect to the datafeed.
         """
         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:
+    def watch(self, symbols: list[tuple[str, models.RecordType]]):
         """
-        Start watching market data for the specified symbols and timeframes.
+        Start watching symbols.
 
         Args:
-            symbols: List of (symbol, timeframe) tuples to start watching.
-
-        Returns:
-            bool: True if watching started successfully, False otherwise.
+            symbols (list[tuple[str, models.TimeFrame]]): List of symbols to watch with
+                their respective timeframes.
         """
-        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
+        pass
 
     @abc.abstractmethod
-    def _watch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
+    def unwatch(self, symbols: list[tuple[str, models.RecordType]]):
         """
-        Implement watching startup logic for the specific datafeed.
+        Stop watching symbols.
 
         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.
+            symbols (list[tuple[str, models.TimeFrame]]): List of symbols to stop
+                watching with their respective timeframes.
         """
         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:
+    def disconnect(self):
         """
-        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.
+        Disconnect from the datafeed.
         """
         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()

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/indicators/base_indicator.py

@@ -0,0 +1,137 @@
+"""
+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
+    `<indicator_instance>.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
+
+    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)
+
+    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
+
+    @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]
+
+    @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

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.dist-info → onesecondtrader-0.12.0.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.10.1
+Version: 0.12.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
+License-File: LICENSE
 Author: Nils P. Kujath
 Author-email: 63961429+NilsKujath@users.noreply.github.com
 Requires-Python: >=3.11
@@ -9,7 +10,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 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.12.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+onesecondtrader/__init__.py,sha256=TNqlT20sH46-J7F6giBxwWYG1-wFZZt7toDbZeQK6KQ,210
+onesecondtrader/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/core/models.py,sha256=I2NgWfZcvlyBPGUSsocrFrhP3KnLFJ-CFt8Cg4GOd0g,4185
+onesecondtrader/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/datafeeds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/datafeeds/base_datafeed.py,sha256=QGXtkVUVN7PsDYeIH8h7Hi_kiDDFcqRyW8K8LzZkRTk,1394
+onesecondtrader/datafeeds/csv_datafeed.py,sha256=WMoZpoian_93CdAzo36hJoF15T0ywRADfuFQcfsPQNc,10957
+onesecondtrader/indicators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/indicators/base_indicator.py,sha256=ipN2uLavRAGvl7Z3z9Zxdzb2MydaZOuJXX86ksalnck,4381
+onesecondtrader/messaging/__init__.py,sha256=9GBHlh6pXweknEacXVBvzpdoTJgVyb3ROLqe1Fhz2ww,179
+onesecondtrader/messaging/eventbus.py,sha256=R2K85INeYVwJ1tMOybC3WpRraK0ZKVe8WehCbAzzznU,19359
+onesecondtrader/messaging/events.py,sha256=eaWXQQIUnRNOR-9n5-6lyLbZ6bUtzjD4GI567U_vh4g,23625
+onesecondtrader/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/monitoring/console.py,sha256=1mrojXkyL4ro7ebkvDMGNQiCL-93WEylRuwnfmEKzVs,299
+onesecondtrader/monitoring/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader-0.12.0.dist-info/METADATA,sha256=H7yohZt3jchO0dUtQuOoEWKJ6GKSM-wCv06qlkYgeNM,9638
+onesecondtrader-0.12.0.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+onesecondtrader-0.12.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.12.0.dist-info/RECORD,,

{onesecondtrader-0.10.1.dist-info → onesecondtrader-0.12.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.0
 Root-Is-Purelib: true
 Tag: py3-none-any

onesecondtrader-0.10.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-onesecondtrader/__init__.py,sha256=TNqlT20sH46-J7F6giBxwWYG1-wFZZt7toDbZeQK6KQ,210
-onesecondtrader/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/core/models.py,sha256=gvspEZp7pISZgpHeaKNQfvNJgwZY7DnS_kWpoGwXC-c,3940
-onesecondtrader/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/datafeeds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/datafeeds/base_datafeed.py,sha256=cHt8bdA9zON6CJLjz7blgNcs4xu4-iWxM15s3Gu3FO0,8774
-onesecondtrader/messaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/messaging/eventbus.py,sha256=R2K85INeYVwJ1tMOybC3WpRraK0ZKVe8WehCbAzzznU,19359
-onesecondtrader/messaging/events.py,sha256=eaWXQQIUnRNOR-9n5-6lyLbZ6bUtzjD4GI567U_vh4g,23625
-onesecondtrader/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/monitoring/console.py,sha256=1mrojXkyL4ro7ebkvDMGNQiCL-93WEylRuwnfmEKzVs,299
-onesecondtrader/monitoring/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader-0.10.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.10.1.dist-info/METADATA,sha256=tGtxjkcRkaC39mi4glsawyMVYHmuBDzpsZQwR4-k3nY,9519
-onesecondtrader-0.10.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-onesecondtrader-0.10.1.dist-info/RECORD,,