onesecondtrader 0.10.0__tar.gz → 0.10.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: onesecondtrader
-Version: 0.10.0
+Version: 0.10.1
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 Author: Nils P. Kujath
 Author-email: 63961429+NilsKujath@users.noreply.github.com

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

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.10.0"
+version = "0.10.1"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

{onesecondtrader-0.10.0 → onesecondtrader-0.10.1}/src/onesecondtrader/datafeeds/base_datafeed.py

@@ -1,5 +1,5 @@
 """
-This module provides the base class for datafeeds.
+This module provides the base class for all datafeeds.
 """
 
 import abc
@@ -16,24 +16,21 @@ class BaseDatafeed(abc.ABC):
 
     def __init__(self, event_bus: eventbus.EventBus) -> None:
         """
-        Initializes the datafeed with the provided event bus.
+        Initialize the datafeed with the provided event bus.
 
         Args:
-            event_bus (eventbus.EventBus): The event bus to publish events to.
+            event_bus: The event bus to publish events to.
 
         Attributes:
-            self.event_bus (eventbus.EventBus): The event bus to publish events to.
-            self._lock (threading.Lock): Lock for thread safety.
-            self._is_connected (bool): Whether the datafeed is connected. `True` if
-                  connected, `False` otherwise.
-            self._streamed_symbols (set[tuple[str, models.TimeFrame]]): Set of symbols
-                 and timeframes that are currently being streamed.
+            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._streamed_symbols: set[tuple[str, models.TimeFrame]] = set()
+        self._watched_symbols: set[tuple[str, models.TimeFrame]] = set()
 
     def connect(self) -> bool:
         """
@@ -80,7 +77,6 @@ class BaseDatafeed(abc.ABC):
     def disconnect(self) -> bool:
         """
         Disconnect from the datafeed.
-        Clears the set of streamed symbols.
 
         Returns:
             bool: True if disconnection successful, False otherwise.
@@ -97,7 +93,7 @@ class BaseDatafeed(abc.ABC):
                 success = self._disconnect()
                 if success:
                     self._is_connected = False
-                    self._streamed_symbols.clear()
+                    self._watched_symbols.clear()
                     console.logger.info(
                         f"Successfully disconnected from {self.__class__.__name__}"
                     )
@@ -112,7 +108,7 @@ class BaseDatafeed(abc.ABC):
                     f"Disconnection failed for {self.__class__.__name__}: {e}"
                 )
                 self._is_connected = False
-                self._streamed_symbols.clear()
+                self._watched_symbols.clear()
                 return False
 
     @abc.abstractmethod
@@ -125,77 +121,71 @@ class BaseDatafeed(abc.ABC):
         """
         pass
 
-    def start_streaming_for_symbols(
-        self, symbols: list[tuple[str, models.TimeFrame]]
-    ) -> bool:
+    def watch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
         """
-        Start streaming market data for the specified symbols and timeframes.
+        Start watching market data for the specified symbols and timeframes.
 
         Args:
-            symbols: List of (symbol, timeframe) tuples to start streaming.
+            symbols: List of (symbol, timeframe) tuples to start watching.
 
         Returns:
-            bool: True if streaming started successfully, False otherwise.
+            bool: True if watching started successfully, False otherwise.
         """
         if not symbols:
-            console.logger.warning("No symbols provided for streaming")
+            console.logger.warning("No symbols provided for watching")
             return True
 
         with self._lock:
             if not self._is_connected:
-                console.logger.error("Cannot start streaming: datafeed not connected")
+                console.logger.error("Cannot start watching: datafeed not connected")
                 return False
 
-            new_symbols = set(symbols) - self._streamed_symbols
+            new_symbols = set(symbols) - self._watched_symbols
             if not new_symbols:
-                console.logger.info("All requested symbols are already being streamed")
+                console.logger.info("All requested symbols are already being watched")
                 return True
 
             try:
-                success = self._start_streaming_for_symbols(list(new_symbols))
+                success = self._watch(list(new_symbols))
                 if success:
-                    self._streamed_symbols.update(new_symbols)
+                    self._watched_symbols.update(new_symbols)
                     console.logger.info(
-                        f"Successfully started streaming for {len(new_symbols)} symbols"
+                        f"Successfully started watching {len(new_symbols)} symbols"
                     )
                     return True
                 else:
-                    console.logger.error("Failed to start streaming for symbols")
+                    console.logger.error("Failed to start watching symbols")
                     return False
             except Exception as e:
-                console.logger.error(f"Exception while starting streaming: {e}")
+                console.logger.error(f"Exception while starting watching: {e}")
                 return False
 
     @abc.abstractmethod
-    def _start_streaming_for_symbols(
-        self, symbols: list[tuple[str, models.TimeFrame]]
-    ) -> bool:
+    def _watch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
         """
-        Implement streaming startup logic for the specific datafeed.
+        Implement watching startup logic for the specific datafeed.
 
         Args:
-            symbols: List of (symbol, timeframe) tuples to start streaming.
-                    These are guaranteed to be new symbols not already being streamed.
+            symbols: List of (symbol, timeframe) tuples to start watching.
+                    These are guaranteed to be new symbols not already being watched.
 
         Returns:
-            bool: True if streaming started successfully, False otherwise.
+            bool: True if watching started successfully, False otherwise.
         """
         pass
 
-    def stop_streaming_for_symbols(
-        self, symbols: list[tuple[str, models.TimeFrame]]
-    ) -> bool:
+    def unwatch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
         """
-        Stop streaming market data for the specified symbols and timeframes.
+        Stop watching market data for the specified symbols and timeframes.
 
         Args:
-            symbols: List of (symbol, timeframe) tuples to stop streaming.
+            symbols: List of (symbol, timeframe) tuples to stop watching.
 
         Returns:
-            bool: True if streaming stopped successfully, False otherwise.
+            bool: True if unwatching stopped successfully, False otherwise.
         """
         if not symbols:
-            console.logger.warning("No symbols provided for stopping streaming")
+            console.logger.warning("No symbols provided for unwatching")
             return True
 
         with self._lock:
@@ -203,61 +193,63 @@ class BaseDatafeed(abc.ABC):
                 console.logger.warning(
                     "Datafeed not connected, but removing symbols from tracking"
                 )
-                self._streamed_symbols.difference_update(symbols)
+                self._watched_symbols.difference_update(symbols)
                 return True
 
-            symbols_to_stop = set(symbols) & self._streamed_symbols
+            symbols_to_stop = set(symbols) & self._watched_symbols
             if not symbols_to_stop:
                 console.logger.info(
-                    "None of the requested symbols are currently being streamed"
+                    "None of the requested symbols are currently being watched"
                 )
                 return True
 
-            console.logger.info(
-                f"Stopping streaming for {len(symbols_to_stop)} symbols"
-            )
+            console.logger.info(f"Unwatching {len(symbols_to_stop)} symbols")
             try:
-                success = self._stop_streaming_for_symbols(list(symbols_to_stop))
+                success = self._unwatch(list(symbols_to_stop))
                 if success:
-                    self._streamed_symbols.difference_update(symbols_to_stop)
+                    self._watched_symbols.difference_update(symbols_to_stop)
                     console.logger.info(
-                        f"Successfully stopped streaming for {len(symbols_to_stop)} "
-                        f"symbols"
+                        f"Successfully unwatched {len(symbols_to_stop)} symbols"
                     )
                     return True
                 else:
-                    console.logger.error("Failed to stop streaming for symbols")
+                    console.logger.error("Failed to unwatch symbols")
                     return False
             except Exception as e:
-                console.logger.error(f"Exception while stopping streaming: {e}")
-                self._streamed_symbols.difference_update(symbols_to_stop)
+                console.logger.error(f"Exception while unwatching: {e}")
+                self._watched_symbols.difference_update(symbols_to_stop)
                 return False
 
     @abc.abstractmethod
-    def _stop_streaming_for_symbols(
-        self, symbols: list[tuple[str, models.TimeFrame]]
-    ) -> bool:
+    def _unwatch(self, symbols: list[tuple[str, models.TimeFrame]]) -> bool:
         """
-        Implement streaming shutdown logic for the specific datafeed.
+        Implement unwatching logic for the specific datafeed.
 
         Args:
-            symbols: List of (symbol, timeframe) tuples to stop streaming.
-                    These are guaranteed to be symbols currently being streamed.
+            symbols: List of (symbol, timeframe) tuples to stop watching.
+                    These are guaranteed to be symbols currently being watched.
 
         Returns:
-            bool: True if streaming stopped successfully, False otherwise.
+            bool: True if unwatching stopped successfully, False otherwise.
         """
         pass
 
-    @abc.abstractmethod
-    def preload_bars(
-        self, preload_list: list[tuple[str, models.TimeFrame, int]]
-    ) -> None:
+    def is_connected(self) -> bool:
         """
-        Preload historical bars for the specified symbols, timeframes, and counts.
+        Check if the datafeed is currently connected.
 
-        Args:
-            preload_list: List of (symbol, timeframe, count) tuples specifying
-                         what historical data to preload.
+        Returns:
+            bool: True if connected, False otherwise.
         """
-        pass
+        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()