Qubx 0.6.71__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.72__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/runner.py

@@ -4,10 +4,9 @@ import numpy as np
 import pandas as pd
 from tqdm.auto import tqdm
 
-from qubx import logger
+from qubx import QubxLogConfig, logger
 from qubx.backtester.sentinels import NoDataContinue
 from qubx.backtester.simulated_data import IterableSimulationData
-from qubx.backtester.utils import SimulationDataConfig, TimeGuardedWrapper
 from qubx.core.account import CompositeAccountProcessor
 from qubx.core.basics import SW, DataType, Instrument, TransactionCostsCalculator
 from qubx.core.context import StrategyContext
@@ -41,6 +40,7 @@ from .utils import (
     SimulatedTimeProvider,
     SimulationDataConfig,
     SimulationSetup,
+    TimeGuardedWrapper,
 )
 
 
@@ -356,8 +356,9 @@ class SimulationRunner:
         return False  # No scheduled events, stop simulation
 
     def print_latency_report(self) -> None:
-        _l_r = SW.latency_report()
-        if _l_r is not None:
+        if (_l_r := SW.latency_report()) is not None:
+            _llvl = QubxLogConfig.get_log_level()
+            QubxLogConfig.set_log_level("INFO")
             logger.info(
                 "<BLUE>   Time spent in simulation report   </BLUE>\n<r>"
                 + _frame_to_str(
@@ -365,6 +366,7 @@ class SimulationRunner:
                 )
                 + "</r>"
             )
+            QubxLogConfig.set_log_level(_llvl)
 
     def _create_backtest_context(self) -> IStrategyContext:
         logger.debug(

qubx/connectors/ccxt/adapters/polling_adapter.py

@@ -1,224 +1,206 @@
 """
-Generic polling adapter to convert CCXT fetch_* methods into watch_* behavior.
+Simplified polling adapter to convert CCXT fetch_* methods into watch_* behavior.
 
-This adapter allows any exchange's fetch_* method to be used as a watch_* method
-by implementing intelligent polling with proper resource management and unwatch functionality.
+This adapter provides a much simpler approach:
+- No background tasks or queues
+- get_next_data() waits until it's time to poll, then polls synchronously
+- Time-aligned polling (e.g., 11:30, 11:35, 11:40 for 5-minute intervals)
+- Immediate polling when symbols change
 """
 
 import asyncio
-import concurrent.futures
+import math
 import time
-from asyncio import CancelledError
+from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Set
 
 from qubx import logger
-from qubx.utils.misc import AsyncThreadLoop
+
+# Constants
+DEFAULT_POLL_INTERVAL = 300  # 5 minutes
+MIN_POLL_INTERVAL = 1  # 1 second minimum
+MAX_POLL_INTERVAL = 3600  # 1 hour maximum
+
+
+@dataclass
+class PollingConfig:
+    """Configuration for polling adapter."""
+
+    poll_interval_seconds: float = DEFAULT_POLL_INTERVAL
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not MIN_POLL_INTERVAL <= self.poll_interval_seconds <= MAX_POLL_INTERVAL:
+            raise ValueError(
+                f"poll_interval_seconds must be between {MIN_POLL_INTERVAL} and {MAX_POLL_INTERVAL}, "
+                f"got {self.poll_interval_seconds}"
+            )
 
 
 class PollingToWebSocketAdapter:
     """
-    Generic adapter to convert fetch_* methods to watch_* behavior using intelligent polling.
-
-    This adapter provides:
-    - Dynamic symbol management (add/remove symbols during runtime)
-    - Comprehensive unwatch functionality (symbol-level and complete shutdown)
-    - Proper resource cleanup and error handling
-    - Thread-safe operations for concurrent access
-    - Configurable polling intervals
+    Simplified polling adapter that polls synchronously when data is requested.
+
+    Key features:
+    - No background tasks or queues
+    - Time-aligned polling (respects clock boundaries)
+    - Immediate polling when symbols change
+    - Thread-safe symbol management
     """
 
     def __init__(
         self,
         fetch_method: Callable,
-        poll_interval_seconds: int = 300,  # 5 minutes default
         symbols: Optional[List[str]] = None,
         params: Optional[Dict[str, Any]] = None,
-        use_time_boundaries: bool = False,  # Make boundary logic optional
-        boundary_tolerance_seconds: int = 30,
-        event_loop: Optional[asyncio.AbstractEventLoop] = None,  # Optional explicit loop
+        config: Optional[PollingConfig] = None,
     ):
         """
-        Initialize the polling adapter.
+        Initialize the simplified polling adapter.
 
         Args:
-            fetch_method: The CCXT fetch_* method to call (e.g., self.fetch_funding_rates)
-            poll_interval_seconds: How often to poll in seconds (default: 300 = 5 minutes)
+            fetch_method: The CCXT fetch_* method to call
             symbols: Initial list of symbols to watch
             params: Additional parameters for fetch_method
-            use_time_boundaries: Whether to align polling to time boundaries (like open_interest.py)
-            boundary_tolerance_seconds: Tolerance for boundary alignment (only used if use_time_boundaries=True)
-            event_loop: Optional explicit asyncio event loop to use for background tasks
+            config: PollingConfig instance (uses default if None)
         """
+        self.config = config if config is not None else PollingConfig()
         self.fetch_method = fetch_method
-        self.poll_interval_seconds = poll_interval_seconds
         self.params = params or {}
-        self.adapter_id = f"polling_adapter_{id(self)}"  # Auto-generated for logging
-        self.use_time_boundaries = use_time_boundaries
-        self.boundary_tolerance_seconds = boundary_tolerance_seconds
-        self.event_loop = event_loop  # Store explicit loop if provided
+        self.adapter_id = f"polling_adapter_{id(self)}"
 
         # Thread-safe symbol management
         self._symbols_lock = asyncio.Lock()
         self._symbols: Set[str] = set(symbols or [])
 
-        # Polling state management
-        self._polling_task: Optional[asyncio.Task] = None
-        self._stop_event = asyncio.Event()
-        self._is_running = False
+        # Polling state
+        self._last_poll_time: Optional[float] = None
+        self._symbols_changed = False  # Flag to trigger immediate poll
 
-        # Statistics for monitoring
+        # Statistics
         self._poll_count = 0
         self._error_count = 0
-        self._last_poll_time: Optional[float] = None
 
-        # Data management for awaitable pattern
-        self._data_queue: asyncio.Queue = asyncio.Queue()
-        self._latest_data: Optional[Dict[str, Any]] = None
-        self._data_condition = asyncio.Condition()
-
-    async def start_watching(self) -> None:
+    async def get_next_data(self) -> Dict[str, Any]:
         """
-        Start the polling loop in background.
+        Get the next available data by waiting until it's time to poll, then polling.
 
-        This method starts the background polling task that will continuously
-        fetch data for the configured symbols and store latest results.
+        This method:
+        1. Checks if symbols changed (immediate poll)
+        2. Calculates when next poll should happen based on time alignment
+        3. Waits until that time
+        4. Polls and returns fresh data
+
+        Returns:
+            Dictionary containing fetched data for symbols
         """
-        if self._is_running:
-            logger.warning(f"Adapter {self.adapter_id} is already running")
-            return
+        async with self._symbols_lock:
+            current_symbols = list(self._symbols)
+            symbols_changed = self._symbols_changed
 
-        self._is_running = True
-        self._stop_event.clear()
+        if not current_symbols:
+            raise ValueError(f"No symbols configured for adapter {self.adapter_id}")
 
-        logger.debug(f"Starting polling adapter {self.adapter_id} with {len(self._symbols)} symbols")
+        # If symbols changed, poll immediately
+        if symbols_changed:
+            logger.debug(f"Symbols changed, polling immediately for adapter {self.adapter_id}")
+            async with self._symbols_lock:
+                self._symbols_changed = False
+            return await self._poll_now(current_symbols)
 
-        # Do immediate initial poll before starting background loop
-        async with self._symbols_lock:
-            current_symbols = list(self._symbols)
-        
-        if current_symbols:
-            try:
-                await self._poll_once(current_symbols)
-            except Exception as e:
-                logger.error(f"Initial poll failed for adapter {self.adapter_id}: {e}")
-
-        # Start the polling task for subsequent polls
-        if self.event_loop is not None:
-            # Use explicit loop if provided (for testing environments)
-            
-            # Always use AsyncThreadLoop for cross-thread task submission
-            # This handles both same-thread and cross-thread cases properly
-            async_loop = AsyncThreadLoop(self.event_loop)
-            self._polling_task = async_loop.submit(self._polling_loop())
-        else:
-            # Use current event loop (normal operation)
-            self._polling_task = asyncio.create_task(self._polling_loop())
+        # Calculate wait time for next aligned poll
+        wait_time = self._calculate_wait_time()
 
-    async def get_next_data(self) -> Dict[str, Any]:
+        if wait_time > 0:
+            logger.debug(f"Waiting {wait_time:.1f}s for next poll cycle for adapter {self.adapter_id}")
+            await asyncio.sleep(wait_time)
+
+        # Time to poll
+        logger.debug(f"Polling now for adapter {self.adapter_id}")
+        return await self._poll_now(current_symbols)
+
+    def _calculate_wait_time(self) -> float:
         """
-        Get the next available data (CCXT awaitable pattern).
-        
-        This is the method that watch_* methods should call to get data.
-        It waits for new data from the polling task.
-        
+        Calculate how long to wait until the next aligned poll time.
+
+        For intervals >= 1 minute: aligns to clock boundaries (11:30, 11:35, 11:40)
+        For intervals < 1 minute: uses simple interval-based timing
+
         Returns:
-            Dictionary containing fetched data for symbols
+            Number of seconds to wait (0 if should poll now)
         """
-        if not self._is_running:
-            logger.debug(f"Starting adapter {self.adapter_id} on first data request")
-            await self.start_watching()
-            # Give the background task a chance to start and do initial poll
-            await asyncio.sleep(0.5)
-            
-        # Wait for new data from polling task
-        try:
-            # First, check if we have data immediately available
-            try:
-                data = self._data_queue.get_nowait()
-                return data
-            except asyncio.QueueEmpty:
-                pass
-            
-            # If no immediate data, wait with timeout
-            data = await asyncio.wait_for(self._data_queue.get(), timeout=30.0)
-            return data
-        except asyncio.TimeoutError:
-            logger.debug(f"Timeout waiting for data from adapter {self.adapter_id}, falling back to cached data")
-            
-            # If no new data, return latest data if available
-            if self._latest_data is not None:
-                return self._latest_data
-            else:
-                # Try a manual poll as fallback - this handles pytest environment issues
-                async with self._symbols_lock:
-                    current_symbols = list(self._symbols)
-                if current_symbols:
-                    try:
-                        await self._poll_once(current_symbols)
-                        if self._latest_data is not None:
-                            return self._latest_data
-                    except Exception as e:
-                        logger.error(f"Manual poll failed for adapter {self.adapter_id}: {e}")
-                
-                raise TimeoutError(f"No data available from polling adapter {self.adapter_id}")
+        current_time = time.time()
+        interval_seconds = self.config.poll_interval_seconds
 
-    async def stop(self) -> None:
-        """
-        Stop polling completely and cleanup all resources.
+        # First poll is always immediate
+        if self._last_poll_time is None:
+            return 0
+
+        if interval_seconds >= 60:
+            # Time-aligned polling for intervals >= 1 minute using UTC
+            # Calculate next boundary based on seconds since epoch
+            next_boundary = math.ceil(current_time / interval_seconds) * interval_seconds
+            wait_time = next_boundary - current_time
+            return max(0, wait_time)
+        else:
+            # Simple interval-based polling for sub-minute intervals
+            next_poll_time = self._last_poll_time + interval_seconds
+            wait_time = next_poll_time - current_time
+            return max(0, wait_time)
+
+    async def _poll_now(self, symbols: List[str]) -> Dict[str, Any]:
         """
-        if not self._is_running:
-            return
+        Perform a poll operation immediately.
 
-        logger.debug(f"Stopping polling adapter {self.adapter_id}")
+        Args:
+            symbols: List of symbols to poll for
 
-        # Signal stop
-        self._stop_event.set()
-        self._is_running = False
+        Returns:
+            Dictionary containing fetched data for symbols
+        """
+        self._poll_count += 1
+        self._last_poll_time = time.time()
 
-        # Clear data queue to prevent stale results from being processed
-        while not self._data_queue.empty():
-            try:
-                self._data_queue.get_nowait()
-            except asyncio.QueueEmpty:
-                break
+        logger.debug(f"Polling {len(symbols)} symbols for adapter {self.adapter_id}")
 
-        await self._cleanup_polling_task()
+        try:
+            # Filter out adapter-specific parameters
+            adapter_params = {"pollInterval", "interval", "updateInterval", "poll_interval_minutes"}
+            fetch_params = {k: v for k, v in self.params.items() if k not in adapter_params}
 
-        logger.debug(f"Adapter {self.adapter_id} stopped (polled {self._poll_count} times, {self._error_count} errors)")
+            # Call the fetch method
+            result = await self.fetch_method(symbols, **fetch_params)
 
-    async def _cleanup_polling_task(self) -> None:
-        """Clean up the polling task."""
-        if self._polling_task and not self._polling_task.done():
-            try:
-                # Handle both Task (normal operation) and Future (explicit event loop) objects
-                if hasattr(self._polling_task, 'result') and not hasattr(self._polling_task, '__await__'):
-                    # This is a Future from AsyncThreadLoop.submit()
-                    self._polling_task.result(timeout=5.0)
-                else:
-                    # This is a regular Task
-                    await asyncio.wait_for(self._polling_task, timeout=5.0)
-            except (asyncio.TimeoutError, concurrent.futures.TimeoutError):
-                logger.debug(f"Polling task for adapter {self.adapter_id} didn't stop gracefully, cancelling")
-                self._polling_task.cancel()
-                try:
-                    if hasattr(self._polling_task, 'result') and not hasattr(self._polling_task, '__await__'):
-                        # Future cancellation is handled by the future itself
-                        pass
-                    else:
-                        # Task cancellation
-                        await self._polling_task
-                except (CancelledError, concurrent.futures.CancelledError):
-                    pass
-
-        self._polling_task = None
+            logger.debug(f"Poll completed successfully for adapter {self.adapter_id}")
+            return result
 
-    async def add_symbols(self, new_symbols: List[str]) -> None:
+        except Exception as e:
+            self._error_count += 1
+            logger.error(f"Poll failed for adapter {self.adapter_id}: {e}")
+            raise
+
+    async def update_symbols(self, new_symbols: List[str]) -> None:
         """
-        Add symbols to the existing watch list.
+        Update the symbol list.
+
+        If symbols changed, the next call to get_next_data() will poll immediately.
 
         Args:
-            new_symbols: List of symbols to add
+            new_symbols: New complete list of symbols to watch
         """
+        async with self._symbols_lock:
+            old_symbols = self._symbols.copy()
+            self._symbols = set(new_symbols or [])
+            symbols_changed = old_symbols != self._symbols
+
+            if symbols_changed:
+                self._symbols_changed = True
+                logger.debug(
+                    f"Symbols updated for adapter {self.adapter_id}: {len(old_symbols)} -> {len(self._symbols)}"
+                )
+
+    async def add_symbols(self, new_symbols: List[str]) -> None:
+        """Add symbols to the existing watch list."""
         if not new_symbols:
             return
 
@@ -226,18 +208,13 @@ class PollingToWebSocketAdapter:
             before_count = len(self._symbols)
             self._symbols.update(new_symbols)
             after_count = len(self._symbols)
-            added_count = after_count - before_count
 
-        if added_count > 0:
-            logger.debug(f"Added {added_count} symbols to adapter {self.adapter_id} (total: {after_count})")
+            if after_count > before_count:
+                self._symbols_changed = True
+                logger.debug(f"Added {after_count - before_count} symbols to adapter {self.adapter_id}")
 
     async def remove_symbols(self, symbols_to_remove: List[str]) -> None:
-        """
-        Remove specific symbols from the watch list.
-
-        Args:
-            symbols_to_remove: List of symbols to remove
-        """
+        """Remove symbols from the watch list."""
         if not symbols_to_remove:
             return
 
@@ -245,195 +222,29 @@ class PollingToWebSocketAdapter:
             before_count = len(self._symbols)
             self._symbols.difference_update(symbols_to_remove)
             after_count = len(self._symbols)
-            removed_count = before_count - after_count
 
-        if removed_count > 0:
-            logger.debug(f"Removed {removed_count} symbols from adapter {self.adapter_id} (total: {after_count})")
-
-        # If no symbols left, we could optionally stop polling
-        # For now, we'll keep polling in case symbols are added back
-
-    async def update_symbols(self, new_symbols: List[str]) -> None:
-        """
-        Replace entire symbol list (atomic operation).
-
-        Args:
-            new_symbols: New complete list of symbols to watch
-        """
-        async with self._symbols_lock:
-            old_symbols = self._symbols.copy()
-            self._symbols = set(new_symbols or [])
-
-        logger.debug(f"Updated symbols for adapter {self.adapter_id}: {len(old_symbols)} -> {len(self._symbols)}")
+            if after_count < before_count:
+                self._symbols_changed = True
+                logger.debug(f"Removed {before_count - after_count} symbols from adapter {self.adapter_id}")
 
     def is_watching(self, symbol: Optional[str] = None) -> bool:
-        """
-        Check if adapter has symbols configured to watch.
-
-        Args:
-            symbol: Optional specific symbol to check. If None, checks if has any symbols.
-
-        Returns:
-            True if has the specified symbol (or any symbols if symbol=None)
-        """
+        """Check if adapter has symbols configured to watch."""
         if symbol is None:
             return len(self._symbols) > 0
         else:
             return symbol in self._symbols
 
-    def is_running(self) -> bool:
-        """
-        Check if adapter is actively running (polling).
-
-        Returns:
-            True if adapter is currently running
-        """
-        return self._is_running
-
     def get_statistics(self) -> Dict[str, Any]:
         """Get adapter statistics for monitoring."""
         return {
             "adapter_id": self.adapter_id,
-            "is_running": self._is_running,
             "symbol_count": len(self._symbols),
             "poll_count": self._poll_count,
             "error_count": self._error_count,
             "last_poll_time": self._last_poll_time,
-            "poll_interval_seconds": self.poll_interval_seconds,
+            "poll_interval_seconds": self.config.poll_interval_seconds,
         }
 
-    async def _polling_loop(self) -> None:
-        """
-        Main polling loop that runs in the background.
-        """
-        # Always do an initial poll immediately  
-        first_poll = True
-        
-        # Ensure we yield control to allow other tasks to run
-        await asyncio.sleep(0)
-
-        try:
-            while not self._stop_event.is_set():
-                try:
-                    # Get current symbols (thread-safe)
-                    async with self._symbols_lock:
-                        current_symbols = list(self._symbols)
-
-                    # Skip polling if no symbols
-                    if not current_symbols:
-                        await self._cancellable_sleep(10)  # Short sleep when no symbols
-                        continue
-
-                    # Determine if we should poll now
-                    should_poll = first_poll or self._should_poll_now()
-
-                    if should_poll:
-                        await self._poll_once(current_symbols)
-                        first_poll = False
-
-                        # Sleep longer after successful poll
-                        sleep_time = self.poll_interval_seconds if not self.use_time_boundaries else 60
-                        await self._cancellable_sleep(sleep_time)
-                    else:
-                        # Not time to poll yet, sleep briefly and check again
-                        await self._cancellable_sleep(5)
-
-                except CancelledError:
-                    break
-                except Exception as e:
-                    self._error_count += 1
-                    logger.error(f"Polling error in adapter {self.adapter_id}: {e}")
-
-                    # Sleep before retry, but not too long
-                    # Ensure minimum 1 second sleep to avoid tight retry loops
-                    sleep_time = max(1, min(30, self.poll_interval_seconds // 10))
-                    await self._cancellable_sleep(sleep_time)
-
-        except CancelledError:
-            pass
-        finally:
-            logger.debug(f"Polling loop stopped for adapter {self.adapter_id}")
-
-    def _should_poll_now(self) -> bool:
-        """
-        Determine if we should poll now based on timing logic.
-
-        Returns:
-            True if we should poll now
-        """
-        if not self.use_time_boundaries:
-            # Simple interval-based polling
-            if self._last_poll_time is None:
-                return True
-            return (time.time() - self._last_poll_time) >= self.poll_interval_seconds
-        else:
-            # Boundary-based polling (like the open_interest.py logic)
-            # This would need access to data provider time, which we don't have here
-            # For now, fall back to simple interval polling
-            # TODO: Implement boundary logic if needed when data provider is available
-            if self._last_poll_time is None:
-                return True
-            return (time.time() - self._last_poll_time) >= self.poll_interval_seconds
-
-    async def _poll_once(self, symbols: List[str]) -> None:
-        """
-        Perform a single polling operation.
-
-        Args:
-            symbols: List of symbols to poll for
-        """
-        self._poll_count += 1
-        self._last_poll_time = time.time()
-
-        logger.debug(f"Polling {len(symbols)} symbols for adapter {self.adapter_id}")
-
-        try:
-            # Filter out adapter-specific parameters before calling fetch method
-            # These parameters are for the adapter, not the underlying fetch method
-            adapter_params = {'pollInterval', 'interval', 'updateInterval'}
-            fetch_params = {k: v for k, v in self.params.items() if k not in adapter_params}
-            
-            # Call the fetch method with symbols and filtered params
-            result = await self.fetch_method(symbols, **fetch_params)
-
-            # Check if we've been stopped while the fetch was happening
-            if self._stop_event.is_set():
-                return
-
-            # Store result and put it in queue for get_next_data to return
-            self._latest_data = result
-
-            # Put data in queue for get_next_data to return
-            try:
-                self._data_queue.put_nowait(result)
-            except asyncio.QueueFull:
-                # Clear old data and add new
-                try:
-                    self._data_queue.get_nowait()
-                except asyncio.QueueEmpty:
-                    pass
-                self._data_queue.put_nowait(result)
-
-        except Exception as e:
-            # Check if we've been stopped during the error
-            if self._stop_event.is_set():
-                return
-            # Re-raise to be handled by polling loop
-            logger.error(f"Fetch failed for adapter {self.adapter_id}: {e}")
-            raise
-
-    async def _cancellable_sleep(self, seconds: float) -> None:
-        """
-        Sleep that can be interrupted by the stop event.
-
-        Args:
-            seconds: Number of seconds to sleep
-        """
-        if seconds <= 0:
-            return
-
-        try:
-            await asyncio.wait_for(self._stop_event.wait(), timeout=seconds)
-        except asyncio.TimeoutError:
-            # Timeout is expected - means we slept for the full duration
-            pass
+    async def stop(self) -> None:
+        """Stop the adapter (cleanup method for compatibility)."""
+        logger.debug(f"Adapter {self.adapter_id} stopped (polled {self._poll_count} times, {self._error_count} errors)")