Qubx 0.6.76__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.78__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/cli/release.py

@@ -84,9 +84,12 @@ def resolve_relative_import(relative_module: str, file_path: str, project_root:
     # Get the directory containing the file (remove filename)
     file_dir = os.path.dirname(rel_file_path)
     
-    # Convert file directory path to module path 
+    # Convert file directory path to module path
     if file_dir:
         current_module_parts = file_dir.replace(os.sep, ".").split(".")
+        # Remove 'src' prefix if present (common Python project structure)
+        if current_module_parts[0] == "src" and len(current_module_parts) > 1:
+            current_module_parts = current_module_parts[1:]
     else:
         current_module_parts = []
     
@@ -684,8 +687,8 @@ def _copy_dependencies(strategy_path: str, pyproject_root: str, release_dir: str
     if _src_root is None:
         raise DependencyResolutionError(f"Could not find the source root for {_src_dir} in {pyproject_root}")
 
-    # Now call _get_imports with the correct source root directory
-    _imports = _get_imports(strategy_path, _src_root, [_src_dir])
+    # Now call _get_imports with the correct source root directory and pyproject_root for relative imports
+    _imports = _get_imports(strategy_path, _src_root, [_src_dir], pyproject_root)
 
     # Validate all dependencies before copying
     valid_imports, missing_dependencies = _validate_dependencies(_imports, _src_root, _src_dir)
@@ -920,7 +923,7 @@ def _create_zip_archive(output_dir: str, release_dir: str, tag: str) -> None:
     shutil.rmtree(release_dir)
 
 
-def _get_imports(file_name: str, current_directory: str, what_to_look: list[str]) -> list[Import]:
+def _get_imports(file_name: str, current_directory: str, what_to_look: list[str], pyproject_root: str | None = None, visited: set[str] | None = None) -> list[Import]:
     """
     Recursively get all imports from a file and its dependencies.
     
@@ -928,6 +931,8 @@ def _get_imports(file_name: str, current_directory: str, what_to_look: list[str]
         file_name: Path to the Python file to analyze
         current_directory: Root directory for resolving imports
         what_to_look: List of module prefixes to filter for
+        pyproject_root: Root directory of the project for resolving relative imports
+        visited: Set of already visited files to prevent infinite recursion
         
     Returns:
         List of Import objects for all discovered dependencies
@@ -935,8 +940,20 @@ def _get_imports(file_name: str, current_directory: str, what_to_look: list[str]
     Raises:
         DependencyResolutionError: If a required dependency cannot be found or processed
     """
+    # Initialize visited set if not provided
+    if visited is None:
+        visited = set()
+    
+    # Skip if already visited to prevent infinite recursion
+    if file_name in visited:
+        return []
+    visited.add(file_name)
+    
+    # Use pyproject_root if provided, otherwise use current_directory as fallback
+    project_root_for_resolution = pyproject_root or current_directory
+    
     try:
-        imports = list(get_imports(file_name, what_to_look, project_root=current_directory))
+        imports = list(get_imports(file_name, what_to_look, project_root=project_root_for_resolution))
     except (SyntaxError, FileNotFoundError) as e:
         raise DependencyResolutionError(f"Failed to parse imports from {file_name}: {e}")
     
@@ -959,7 +976,7 @@ def _get_imports(file_name: str, current_directory: str, what_to_look: list[str]
             if dependency_file:
                 # Recursively process the dependency
                 try:
-                    imports.extend(_get_imports(dependency_file, current_directory, what_to_look))
+                    imports.extend(_get_imports(dependency_file, current_directory, what_to_look, pyproject_root, visited))
                 except DependencyResolutionError as e:
                     # Log nested dependency errors but continue processing
                     logger.warning(f"Failed to resolve nested dependency: {e}")

qubx/connectors/ccxt/account.py

@@ -28,6 +28,7 @@ from qubx.utils.marketdata.ccxt import ccxt_symbol_to_instrument
 from qubx.utils.misc import AsyncThreadLoop
 
 from .exceptions import CcxtSymbolNotRecognized
+from .exchange_manager import ExchangeManager
 from .utils import (
     ccxt_convert_balance,
     ccxt_convert_deal_info,
@@ -46,7 +47,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     Subscribes to account information from the exchange.
     """
 
-    exchange: cxp.Exchange
+    exchange_manager: ExchangeManager
     channel: CtrlChannel
     base_currency: str
     balance_interval: str
@@ -69,7 +70,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     def __init__(
         self,
         account_id: str,
-        exchange: cxp.Exchange,
+        exchange_manager: ExchangeManager,
         channel: CtrlChannel,
         time_provider: ITimeProvider,
         base_currency: str,
@@ -90,7 +91,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             tcc=tcc,
             initial_capital=0,
         )
-        self.exchange = exchange
+        self.exchange_manager = exchange_manager
         self.channel = channel
         self.max_retries = max_retries
         self.balance_interval = balance_interval
@@ -99,7 +100,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self.open_order_interval = open_order_interval
         self.open_order_backoff = open_order_backoff
         self.max_position_restore_days = max_position_restore_days
-        self._loop = AsyncThreadLoop(exchange.asyncio_loop)
+        self._loop = AsyncThreadLoop(exchange_manager.exchange.asyncio_loop)
         self._is_running = False
         self._polling_tasks = {}
         self._polling_to_init = defaultdict(bool)
@@ -125,7 +126,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
         self._is_running = True
 
-        if not self.exchange.isSandboxModeEnabled:
+        if not self.exchange_manager.exchange.isSandboxModeEnabled:
             # - start polling tasks
             self._polling_tasks["balance"] = self._loop.submit(
                 self._poller("balance", self._update_balance, self.balance_interval)
@@ -178,8 +179,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
     def _get_instrument_for_currency(self, currency: str) -> Instrument:
         symbol = f"{currency}/{self.base_currency}"
-        market = self.exchange.market(symbol)
-        exchange_name = self.exchange.name
+        market = self.exchange_manager.exchange.market(symbol)
+        exchange_name = self.exchange_manager.exchange.name
         assert exchange_name is not None
         return ccxt_symbol_to_instrument(exchange_name, market)
 
@@ -267,7 +268,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
     async def _update_balance(self) -> None:
         """Fetch and update balances from exchange"""
-        balances_raw = await self.exchange.fetch_balance()
+        balances_raw = await self.exchange_manager.exchange.fetch_balance()
         balances = ccxt_convert_balance(balances_raw)
         current_balances = self.get_balances()
 
@@ -292,8 +293,8 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
     async def _update_positions(self) -> None:
         # fetch and update positions from exchange
-        ccxt_positions = await self.exchange.fetch_positions()
-        positions = ccxt_convert_positions(ccxt_positions, self.exchange.name, self.exchange.markets)  # type: ignore
+        ccxt_positions = await self.exchange_manager.exchange.fetch_positions()
+        positions = ccxt_convert_positions(ccxt_positions, self.exchange_manager.exchange.name, self.exchange_manager.exchange.markets)  # type: ignore
         # update required instruments that we need to subscribe to
         self._required_instruments.update([p.instrument for p in positions])
         # update positions
@@ -358,7 +359,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         if _fetch_instruments:
             logger.debug(f"Fetching missing tickers for {_fetch_instruments}")
             _fetch_symbols = [instrument_to_ccxt_symbol(instr) for instr in _fetch_instruments]
-            tickers: dict[str, dict] = await self.exchange.fetch_tickers(_fetch_symbols)
+            tickers: dict[str, dict] = await self.exchange_manager.exchange.fetch_tickers(_fetch_symbols)
             for symbol, ticker in tickers.items():
                 instr = _symbol_to_instrument.get(symbol)
                 if instr is not None:
@@ -457,7 +458,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
             async def _cancel_order(order: Order) -> None:
                 try:
-                    await self.exchange.cancel_order(order.id, symbol=instrument_to_ccxt_symbol(order.instrument))
+                    await self.exchange_manager.exchange.cancel_order(order.id, symbol=instrument_to_ccxt_symbol(order.instrument))
                     logger.debug(
                         f"  :: [SYNC] Canceled {order.id} {order.instrument.symbol} {order.side} {order.quantity} @ {order.price} ({order.status})"
                     )
@@ -475,7 +476,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     ) -> dict[str, Order]:
         _start_ms = self._get_start_time_in_ms(days_before) if limit is None else None
         _ccxt_symbol = instrument_to_ccxt_symbol(instrument)
-        _fetcher = self.exchange.fetch_open_orders if is_open else self.exchange.fetch_orders
+        _fetcher = self.exchange_manager.exchange.fetch_open_orders if is_open else self.exchange_manager.exchange.fetch_orders
         _raw_orders = await _fetcher(_ccxt_symbol, since=_start_ms, limit=limit)
         _orders = [ccxt_convert_order_info(instrument, o) for o in _raw_orders]
         _id_to_order = {o.id: o for o in _orders}
@@ -484,7 +485,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _fetch_deals(self, instrument: Instrument, days_before: int = 30) -> list[Deal]:
         _start_ms = self._get_start_time_in_ms(days_before)
         _ccxt_symbol = instrument_to_ccxt_symbol(instrument)
-        deals_data = await self.exchange.fetch_my_trades(_ccxt_symbol, since=_start_ms)
+        deals_data = await self.exchange_manager.exchange.fetch_my_trades(_ccxt_symbol, since=_start_ms)
         deals: list[Deal] = [ccxt_convert_deal_info(o) for o in deals_data]
         return sorted(deals, key=lambda x: x.time) if deals else []
 
@@ -530,9 +531,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         _symbol_to_instrument = {}
 
         async def _watch_executions():
-            exec = await self.exchange.watch_orders()
+            exec = await self.exchange_manager.exchange.watch_orders()
             for report in exec:
-                instrument = ccxt_find_instrument(report["symbol"], self.exchange, _symbol_to_instrument)
+                instrument = ccxt_find_instrument(report["symbol"], self.exchange_manager.exchange, _symbol_to_instrument)
                 order = ccxt_convert_order_info(instrument, report)
                 deals = ccxt_extract_deals_from_exec(report)
                 channel.send((instrument, "order", order, False))
@@ -541,7 +542,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
         await self._listen_to_stream(
             subscriber=_watch_executions,
-            exchange=self.exchange,
+            exchange=self.exchange_manager.exchange,
             channel=channel,
             name=name,
         )

qubx/connectors/ccxt/subscription_manager.py

@@ -8,7 +8,7 @@ separating subscription concerns from connection management and data handling.
 from collections import defaultdict
 from typing import Dict, List, Set
 
-from qubx.core.basics import Instrument
+from qubx.core.basics import DataType, Instrument
 
 
 class SubscriptionManager:
@@ -37,7 +37,7 @@ class SubscriptionManager:
 
         # Symbol to instrument mapping for quick lookups
         self._symbol_to_instrument: dict[str, Instrument] = {}
-        
+
         # Individual stream mappings: {subscription_type: {instrument: stream_name}}
         self._individual_streams: dict[str, dict[Instrument, str]] = defaultdict(dict)
 
@@ -125,7 +125,7 @@ class SubscriptionManager:
 
         # Clean up name mapping
         self._sub_to_name.pop(subscription_type, None)
-        
+
         # Clean up individual stream mappings
         self._individual_streams.pop(subscription_type, None)
 
@@ -163,15 +163,21 @@ class SubscriptionManager:
         """
         if instrument is not None:
             # Return subscriptions (both active and pending) that contain this instrument
-            active = [sub for sub, instrs in self._subscriptions.items() 
-                     if instrument in instrs and self._sub_connection_ready.get(sub, False)]
+            active = [
+                sub
+                for sub, instrs in self._subscriptions.items()
+                if instrument in instrs and self._sub_connection_ready.get(sub, False)
+            ]
             pending = [sub for sub, instrs in self._pending_subscriptions.items() if instrument in instrs]
             return list(set(active + pending))
 
         # Return all subscription types that have any instruments (both active and pending)
         # Only include active subscriptions if connection is ready
-        active = [sub for sub, instruments in self._subscriptions.items() 
-                 if instruments and self._sub_connection_ready.get(sub, False)]
+        active = [
+            sub
+            for sub, instruments in self._subscriptions.items()
+            if instruments and self._sub_connection_ready.get(sub, False)
+        ]
         pending = [sub for sub, instruments in self._pending_subscriptions.items() if instruments]
         return list(set(active + pending))
 
@@ -211,17 +217,24 @@ class SubscriptionManager:
 
         Args:
             instrument: Instrument to check
-            subscription_type: Full subscription type (e.g., "ohlc(1m)")
+            subscription_type: Base or full subscription type (e.g., "orderbook" or "orderbook(0.0, 20)")
 
         Returns:
             True if subscription is active (not just pending)
         """
-        # Only return True if subscription is actually active (not just pending)
-        return (
-            subscription_type in self._subscriptions
-            and instrument in self._subscriptions[subscription_type]
-            and self._sub_connection_ready.get(subscription_type, False)
-        )
+        # Get the base type for comparison
+        base_type = DataType.from_str(subscription_type)[0]
+
+        # Check if any subscription with matching base type contains the instrument and is ready
+        for stored_sub_type, instruments in self._subscriptions.items():
+            if (
+                DataType.from_str(stored_sub_type)[0] == base_type
+                and instrument in instruments
+                and self._sub_connection_ready.get(stored_sub_type, False)
+            ):
+                return True
+
+        return False
 
     def has_pending_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
         """
@@ -229,16 +242,24 @@ class SubscriptionManager:
 
         Args:
             instrument: Instrument to check
-            subscription_type: Full subscription type (e.g., "ohlc(1m)")
+            subscription_type: Base or full subscription type (e.g., "orderbook" or "orderbook(0.0, 20)")
 
         Returns:
             True if subscription is pending (connection being established)
         """
-        return (
-            subscription_type in self._pending_subscriptions
-            and instrument in self._pending_subscriptions[subscription_type]
-            and not self._sub_connection_ready.get(subscription_type, False)
-        )
+        # Get the base type for comparison
+        base_type = DataType.from_str(subscription_type)[0]
+
+        # Check if any pending subscription with matching base type contains the instrument and is not ready
+        for stored_sub_type, instruments in self._pending_subscriptions.items():
+            if (
+                DataType.from_str(stored_sub_type)[0] == base_type
+                and instrument in instruments
+                and not self._sub_connection_ready.get(stored_sub_type, False)
+            ):
+                return True
+
+        return False
 
     def get_all_subscribed_instruments(self) -> Set[Instrument]:
         """
@@ -262,14 +283,14 @@ class SubscriptionManager:
             True if connection is established and ready
         """
         return self._sub_connection_ready.get(subscription_type, False)
-    
+
     def has_subscription_type(self, subscription_type: str) -> bool:
         """
         Check if a subscription type exists (has any instruments).
-        
+
         Args:
             subscription_type: Full subscription type (e.g., "ohlc(1m)")
-            
+
         Returns:
             True if subscription type has any instruments
         """
@@ -283,33 +304,33 @@ class SubscriptionManager:
             Dictionary mapping symbols to instruments
         """
         return self._symbol_to_instrument.copy()
-    
+
     def set_individual_streams(self, subscription_type: str, streams: dict[Instrument, str]) -> None:
         """
         Store individual stream mappings for a subscription type.
-        
+
         Args:
             subscription_type: Full subscription type (e.g., "ohlc(1m)")
             streams: Dictionary mapping instrument to stream name
         """
         self._individual_streams[subscription_type] = streams
-    
+
     def get_individual_streams(self, subscription_type: str) -> dict[Instrument, str]:
         """
         Get individual stream mappings for a subscription type.
-        
+
         Args:
             subscription_type: Full subscription type (e.g., "ohlc(1m)")
-            
+
         Returns:
             Dictionary mapping instrument to stream name
         """
         return self._individual_streams.get(subscription_type, {})
-    
+
     def clear_individual_streams(self, subscription_type: str) -> None:
         """
         Clear individual stream mappings for a subscription type.
-        
+
         Args:
             subscription_type: Full subscription type (e.g., "ohlc(1m)")
         """

qubx/core/account.py

@@ -18,6 +18,7 @@ from qubx.core.basics import (
 )
 from qubx.core.helpers import extract_price
 from qubx.core.interfaces import IAccountProcessor, ISubscriptionManager
+from qubx.core.mixins.utils import EXCHANGE_MAPPINGS
 
 
 class BasicAccountProcessor(IAccountProcessor):
@@ -75,6 +76,9 @@ class BasicAccountProcessor(IAccountProcessor):
     def get_positions(self, exchange: str | None = None) -> dict[Instrument, Position]:
         return self._positions
 
+    def get_fees_calculator(self, exchange: str | None = None) -> TransactionCostsCalculator:
+        return self._tcc
+
     def get_position(self, instrument: Instrument) -> Position:
         _pos = self._positions.get(instrument)
         if _pos is None:
@@ -353,11 +357,20 @@ class CompositeAccountProcessor(IAccountProcessor):
         """
         if exchange:
             if exchange not in self._account_processors:
+                # Check if there's a mapping for this exchange
+                if exchange in EXCHANGE_MAPPINGS and EXCHANGE_MAPPINGS[exchange] in self._account_processors:
+                    return EXCHANGE_MAPPINGS[exchange]
                 raise ValueError(f"Unknown exchange: {exchange}")
             return exchange
 
         if instrument:
             if instrument.exchange not in self._account_processors:
+                # Check if there's a mapping for this exchange
+                if (
+                    instrument.exchange in EXCHANGE_MAPPINGS
+                    and EXCHANGE_MAPPINGS[instrument.exchange] in self._account_processors
+                ):
+                    return EXCHANGE_MAPPINGS[instrument.exchange]
                 raise ValueError(f"Unknown exchange: {instrument.exchange}")
             return instrument.exchange
 
@@ -443,6 +456,10 @@ class CompositeAccountProcessor(IAccountProcessor):
         exch = self._get_exchange(exchange)
         return self._account_processors[exch].position_report()
 
+    def get_fees_calculator(self, exchange: str | None = None) -> TransactionCostsCalculator:
+        exch = self._get_exchange(exchange)
+        return self._account_processors[exch].get_fees_calculator()
+
     ########################################################
     # Leverage information
     ########################################################

qubx/core/context.py

@@ -15,6 +15,7 @@ from qubx.core.basics import (
     Order,
     OrderRequest,
     Position,
+    RestoredState,
     Signal,
     TargetPosition,
     Timestamped,
@@ -112,6 +113,7 @@ class StrategyContext(IStrategyContext):
         strategy_name: str | None = None,
         strategy_state: StrategyState | None = None,
         health_monitor: IHealthMonitor | None = None,
+        restored_state: RestoredState | None = None,
     ) -> None:
         self.account = account
         self.strategy = self.__instantiate_strategy(strategy, config)
@@ -138,6 +140,7 @@ class StrategyContext(IStrategyContext):
         self._lifecycle_notifier = lifecycle_notifier
         self._strategy_state = strategy_state if strategy_state is not None else StrategyState()
         self._strategy_name = strategy_name if strategy_name is not None else strategy.__class__.__name__
+        self._restored_state = restored_state
 
         self._health_monitor = health_monitor or DummyHealthMonitor()
         self.health = self._health_monitor
@@ -150,6 +153,8 @@ class StrategyContext(IStrategyContext):
         if __position_gathering is None:
             __position_gathering = position_gathering if position_gathering is not None else SimplePositionGatherer()
 
+        __warmup_position_gathering = SimplePositionGatherer()
+
         self._subscription_manager = SubscriptionManager(
             data_providers=self._data_providers,
             default_base_subscription=DataType.ORDERBOOK
@@ -175,9 +180,10 @@ class StrategyContext(IStrategyContext):
             time_provider=self,
             account=self.account,
             position_gathering=__position_gathering,
+            warmup_position_gathering=__warmup_position_gathering,
         )
         self._trading_manager = TradingManager(
-            time_provider=self,
+            context=self,
             brokers=self._brokers,
             account=self.account,
             strategy_name=self._strategy_name,
@@ -192,6 +198,7 @@ class StrategyContext(IStrategyContext):
             account=self.account,
             position_tracker=__position_tracker,
             position_gathering=__position_gathering,
+            warmup_position_gathering=__warmup_position_gathering,
             universe_manager=self._universe_manager,
             cache=self._cache,
             scheduler=self._scheduler,
@@ -455,11 +462,11 @@ class StrategyContext(IStrategyContext):
     ) -> Order:
         return self._trading_manager.set_target_position(instrument, target, price, **options)
 
-    def close_position(self, instrument: Instrument) -> None:
-        return self._trading_manager.close_position(instrument)
+    def close_position(self, instrument: Instrument, without_signals: bool = False) -> None:
+        return self._trading_manager.close_position(instrument, without_signals)
 
-    def close_positions(self, market_type: MarketType | None = None) -> None:
-        return self._trading_manager.close_positions(market_type)
+    def close_positions(self, market_type: MarketType | None = None, without_signals: bool = False) -> None:
+        return self._trading_manager.close_positions(market_type, without_signals)
 
     def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
         return self._trading_manager.cancel_order(order_id, exchange)
@@ -585,6 +592,9 @@ class StrategyContext(IStrategyContext):
     def get_warmup_orders(self) -> dict[Instrument, list[Order]]:
         return self._warmup_orders if self._warmup_orders is not None else {}
 
+    def get_restored_state(self) -> RestoredState | None:
+        return self._restored_state
+
     # private methods
     def __process_incoming_data_loop(self, channel: CtrlChannel):
         logger.info("[StrategyContext] :: Start processing market data")

qubx/core/interfaces.py

@@ -36,6 +36,7 @@ from qubx.core.basics import (
     Signal,
     TargetPosition,
     Timestamped,
+    TransactionCostsCalculator,
     TriggerEvent,
     dt_64,
     td_64,
@@ -153,6 +154,17 @@ class IAccountViewer:
         """
         ...
 
+    def get_fees_calculator(self, exchange: str | None = None) -> TransactionCostsCalculator:
+        """Get the fees calculator.
+
+        Args:
+            exchange: The exchange to get the fees calculator for
+
+        Returns:
+            TransactionCostsCalculator: The transaction costs calculator
+        """
+        ...
+
     @property
     def positions(self) -> dict[Instrument, Position]:
         """[Deprecated: Use get_positions()] Get all current positions.
@@ -673,15 +685,16 @@ class ITradingManager:
         """
         ...
 
-    def close_position(self, instrument: Instrument) -> None:
+    def close_position(self, instrument: Instrument, without_signals: bool = False) -> None:
         """Close position for an instrument.
 
         Args:
             instrument: The instrument to close position for
+            without_signals: If True, trade submitted instead of emitting signal
         """
         ...
 
-    def close_positions(self, market_type: MarketType | None = None, exchange: str | None = None) -> None:
+    def close_positions(self, market_type: MarketType | None = None, without_signals: bool = False) -> None:
         """Close all positions."""
         ...
 
@@ -1200,6 +1213,10 @@ class IStrategyContext(
         """Get the list of exchanges."""
         return []
 
+    def get_restored_state(self) -> "RestoredState | None":
+        """Get the restored state."""
+        return None
+
 
 class IPositionGathering:
     """
@@ -1226,6 +1243,28 @@ class IPositionGathering:
 
     def on_execution_report(self, ctx: IStrategyContext, instrument: Instrument, deal: Deal): ...
 
+    def update(self, ctx: IStrategyContext, instrument: Instrument, update: Timestamped) -> None:
+        """
+        Position gatherer is being updated by new market data.
+
+        Args:
+            ctx: Strategy context object
+            instrument: The instrument for which market data was updated
+            update: The market data update (Quote, Trade, Bar, etc.)
+        """
+        pass
+
+    def restore_from_target_positions(self, ctx: IStrategyContext, target_positions: list[TargetPosition]) -> None:
+        """
+        Restore gatherer state from target positions.
+
+        Args:
+            ctx: Strategy context object
+            target_positions: List of target positions to restore gatherer state from
+        """
+        # Default implementation - subclasses can override if needed
+        pass
+
 
 class IPositionSizer:
     """Interface for calculating target positions from signals."""
@@ -1307,15 +1346,16 @@ class PositionsTracker:
         """
         ...
 
-    def restore_position_from_target(self, ctx: IStrategyContext, target: TargetPosition):
+    def restore_position_from_signals(self, ctx: IStrategyContext, signals: list[Signal]) -> None:
         """
-        Restore active position and tracking from the target.
+        Restore tracker state from signals.
 
         Args:
-            - ctx: Strategy context object.
-            - target: Target position to restore from.
+            ctx: Strategy context object
+            signals: List of signals to restore tracker state from
         """
-        ...
+        # Default implementation - subclasses can override
+        pass
 
 
 @dataclass
@@ -1350,12 +1390,12 @@ class HealthMetrics:
 @runtime_checkable
 class IDataArrivalListener(Protocol):
     """Interface for components that want to be notified of data arrivals."""
-    
+
     def on_data_arrival(self, event_type: str, event_time: dt_64) -> None:
         """Called when new data arrives.
-        
+
         Args:
-            event_type: Type of data event (e.g., "ohlcv:BTC/USDT:1m") 
+            event_type: Type of data event (e.g., "ohlcv:BTC/USDT:1m")
             event_time: Timestamp of the data event
         """
         ...

qubx/core/loggers.py

@@ -244,6 +244,7 @@ class SignalsAndTargetsLogger(_BaseIntervalDumper):
                 "entry_price": t.entry_price,
                 "take_price": t.take_price,
                 "stop_price": t.stop_price,
+                "options": t.options,
             }
             for t in self._targets
         ]
@@ -262,6 +263,7 @@ class SignalsAndTargetsLogger(_BaseIntervalDumper):
                 "group": s.group,
                 "comment": s.comment,
                 "service": s.is_service,
+                "options": s.options,
             }
             for s in self._signals
         ]

qubx/core/mixins/processing.py

@@ -16,6 +16,7 @@ from qubx.core.basics import (
     Instrument,
     MarketEvent,
     Order,
+    RestoredState,
     Signal,
     TargetPosition,
     Timestamped,
@@ -59,6 +60,7 @@ class ProcessingManager(IProcessingManager):
     _account: IAccountProcessor
     _position_tracker: PositionsTracker
     _position_gathering: IPositionGathering
+    _warmup_position_gathering: IPositionGathering
     _cache: CachedMarketDataHolder
     _scheduler: BasicScheduler
     _universe_manager: IUniverseManager
@@ -101,6 +103,7 @@ class ProcessingManager(IProcessingManager):
         account: IAccountProcessor,
         position_tracker: PositionsTracker,
         position_gathering: IPositionGathering,
+        warmup_position_gathering: IPositionGathering,
         universe_manager: IUniverseManager,
         cache: CachedMarketDataHolder,
         scheduler: BasicScheduler,
@@ -152,6 +155,8 @@ class ProcessingManager(IProcessingManager):
         self._active_targets = {}
         self._custom_scheduled_methods = {}
 
+        self._warmup_position_gathering = warmup_position_gathering
+
         # - schedule daily delisting check at 23:30 (end of day)
         self._scheduler.schedule_event("30 23 * * *", "delisting_check")
 
@@ -254,6 +259,12 @@ class ProcessingManager(IProcessingManager):
         ):
             if self._context.get_warmup_positions() or self._context.get_warmup_orders():
                 self._handle_state_resolution()
+
+            # Restore tracker and gatherer state if available
+            restored_state = self._context.get_restored_state()
+            if restored_state is not None:
+                self._restore_tracker_and_gatherer_state(restored_state)
+
             self._handle_warmup_finished()
 
         # - check if it still didn't call on_fit() for first time
@@ -350,6 +361,13 @@ class ProcessingManager(IProcessingManager):
             else self._position_tracker
         )
 
+    def _get_position_gatherer(self) -> IPositionGathering:
+        return (
+            self._position_gathering
+            if self._context._strategy_state.is_on_warmup_finished_called
+            else self._warmup_position_gathering
+        )
+
     def __preprocess_signals_and_split_by_stage(
         self, signals: list[Signal]
     ) -> tuple[list[Signal], list[Signal], set[Instrument]]:
@@ -428,7 +446,7 @@ class ProcessingManager(IProcessingManager):
 
         # - notify position gatherer for the new target positions
         if _targets_from_trackers:
-            self._position_gathering.alter_positions(
+            self._get_position_gatherer().alter_positions(
                 self._context, self.__preprocess_and_log_target_positions(_targets_from_trackers)
             )
 
@@ -643,15 +661,16 @@ class ProcessingManager(IProcessingManager):
                 # - update tracker
                 _targets_from_tracker = self._get_tracker_for(instrument).update(self._context, instrument, _update)
 
-                # TODO: add gatherer update
-
                 # - notify position gatherer for the new target positions
                 if _targets_from_tracker:
                     # - tracker generated new targets on update, notify position gatherer
-                    self._position_gathering.alter_positions(
+                    self._get_position_gatherer().alter_positions(
                         self._context, self.__preprocess_and_log_target_positions(self._as_list(_targets_from_tracker))
                     )
 
+                # - update position gatherer with market data
+                self._get_position_gatherer().update(self._context, instrument, _update)
+
                 # - check for stale data periodically (only for base data updates)
                 # This ensures we only check when we have new meaningful data
                 if self._stale_data_detection_enabled and self._context._strategy_state.is_on_start_called:
@@ -753,6 +772,37 @@ class ProcessingManager(IProcessingManager):
 
         resolver(_ctx, _ctx.get_warmup_positions(), _ctx.get_warmup_orders(), _ctx.get_warmup_active_targets())
 
+    def _restore_tracker_and_gatherer_state(self, restored_state: RestoredState) -> None:
+        """
+        Restore state for position tracker and gatherer.
+
+        Args:
+            restored_state: The restored state containing signals and target positions
+        """
+        if not self._is_data_ready():
+            return
+
+        # Restore tracker state from signals
+        all_signals = []
+        for instrument, signals in restored_state.instrument_to_signal_positions.items():
+            all_signals.extend(signals)
+
+        if all_signals:
+            logger.info(f"<yellow>Restoring tracker state from {len(all_signals)} signals</yellow>")
+            self._position_tracker.restore_position_from_signals(self._context, all_signals)
+
+        # Restore gatherer state from latest target positions only
+        latest_targets = []
+        for instrument, targets in restored_state.instrument_to_target_positions.items():
+            if targets:  # Only if there are targets for this instrument
+                # Get the latest target position (assuming they are sorted by time)
+                latest_target = max(targets, key=lambda t: t.time)
+                latest_targets.append(latest_target)
+
+        if latest_targets:
+            logger.info(f"<yellow>Restoring gatherer state from {len(latest_targets)} latest target positions</yellow>")
+            self._position_gathering.restore_from_target_positions(self._context, latest_targets)
+
     def _handle_warmup_finished(self) -> None:
         if not self._is_data_ready():
             return
@@ -856,7 +906,7 @@ class ProcessingManager(IProcessingManager):
             # - Process all deals first
             for d in deals:
                 # - notify position gatherer and tracker
-                self._position_gathering.on_execution_report(self._context, instrument, d)
+                self._get_position_gatherer().on_execution_report(self._context, instrument, d)
                 self._get_tracker_for(instrument).on_execution_report(self._context, instrument, d)
 
                 logger.debug(

qubx/core/mixins/trading.py

@@ -3,7 +3,7 @@ from typing import Any
 from qubx import logger
 from qubx.core.basics import Instrument, MarketType, Order, OrderRequest, OrderSide
 from qubx.core.exceptions import OrderNotFound
-from qubx.core.interfaces import IAccountProcessor, IBroker, ITimeProvider, ITradingManager
+from qubx.core.interfaces import IAccountProcessor, IBroker, IStrategyContext, ITimeProvider, ITradingManager
 
 from .utils import EXCHANGE_MAPPINGS
 
@@ -60,7 +60,7 @@ class ClientIdStore:
 
 
 class TradingManager(ITradingManager):
-    _time_provider: ITimeProvider
+    _context: IStrategyContext
     _brokers: list[IBroker]
     _account: IAccountProcessor
     _strategy_name: str
@@ -69,9 +69,9 @@ class TradingManager(ITradingManager):
     _exchange_to_broker: dict[str, IBroker]
 
     def __init__(
-        self, time_provider: ITimeProvider, brokers: list[IBroker], account: IAccountProcessor, strategy_name: str
+        self, context: IStrategyContext, brokers: list[IBroker], account: IAccountProcessor, strategy_name: str
     ) -> None:
-        self._time_provider = time_provider
+        self._context = context
         self._brokers = brokers
         self._account = account
         self._strategy_name = strategy_name
@@ -156,21 +156,27 @@ class TradingManager(ITradingManager):
     ) -> Order:
         raise NotImplementedError("Not implemented yet")
 
-    def close_position(self, instrument: Instrument) -> None:
+    def close_position(self, instrument: Instrument, without_signals: bool = False) -> None:
         position = self._account.get_position(instrument)
 
         if not position.is_open():
             logger.debug(f"[<g>{instrument.symbol}</g>] :: Position already closed or zero size")
             return
 
-        closing_amount = -position.quantity
-        logger.debug(
-            f"[<g>{instrument.symbol}</g>] :: Closing position {position.quantity} with market order for {closing_amount}"
-        )
-
-        self.trade(instrument, closing_amount, reduceOnly=True)
+        if without_signals:
+            closing_amount = -position.quantity
+            logger.debug(
+                f"[<g>{instrument.symbol}</g>] :: Closing position {position.quantity} with market order for {closing_amount}"
+            )
+            self.trade(instrument, closing_amount, reduceOnly=True)
+        else:
+            logger.debug(
+                f"[<g>{instrument.symbol}</g>] :: Closing position {position.quantity} by emitting signal with 0 target"
+            )
+            signal = instrument.signal(self._context, 0, comment="Close position trade")
+            self._context.emit_signal(signal)
 
-    def close_positions(self, market_type: MarketType | None = None) -> None:
+    def close_positions(self, market_type: MarketType | None = None, without_signals: bool = False) -> None:
         positions = self._account.get_positions()
 
         positions_to_close = []
@@ -188,7 +194,7 @@ class TradingManager(ITradingManager):
         )
 
         for instrument in positions_to_close:
-            self.close_position(instrument)
+            self.close_position(instrument, without_signals)
 
     def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
         if not order_id:
@@ -208,7 +214,7 @@ class TradingManager(ITradingManager):
             self.cancel_order(o.id, instrument.exchange)
 
     def _generate_order_client_id(self, symbol: str) -> str:
-        return self._client_id_store.generate_id(self._time_provider, symbol)
+        return self._client_id_store.generate_id(self._context, symbol)
 
     def exchanges(self) -> list[str]:
         return list(self._exchange_to_broker.keys())

qubx/core/mixins/universe.py

@@ -1,4 +1,4 @@
-from qubx.core.basics import DataType, Instrument, TargetPosition
+from qubx.core.basics import DataType, Instrument
 from qubx.core.helpers import CachedMarketDataHolder
 from qubx.core.interfaces import (
     IAccountProcessor,
@@ -24,6 +24,7 @@ class UniverseManager(IUniverseManager):
     _time_provider: ITimeProvider
     _account: IAccountProcessor
     _position_gathering: IPositionGathering
+    _warmup_position_gathering: IPositionGathering
     _removal_queue: dict[Instrument, tuple[RemovalPolicy, bool]]
 
     def __init__(
@@ -37,6 +38,7 @@ class UniverseManager(IUniverseManager):
         time_provider: ITimeProvider,
         account: IAccountProcessor,
         position_gathering: IPositionGathering,
+        warmup_position_gathering: IPositionGathering,
     ):
         self._context = context
         self._strategy = strategy
@@ -50,6 +52,8 @@ class UniverseManager(IUniverseManager):
         self._instruments = set()
         self._removal_queue = {}
 
+        self._warmup_position_gathering = warmup_position_gathering
+
     def _has_position(self, instrument: Instrument) -> bool:
         return (
             instrument in self._account.positions
@@ -107,6 +111,13 @@ class UniverseManager(IUniverseManager):
                 to_remove.append(instr)
         return to_remove, to_keep
 
+    def _get_position_gatherer(self) -> IPositionGathering:
+        return (
+            self._position_gathering
+            if self._context._strategy_state.is_on_warmup_finished_called
+            else self._warmup_position_gathering
+        )
+
     def __cleanup_removal_queue(self, instruments: list[Instrument]):
         for instr in instruments:
             # - if it's still in the removal queue, remove it
@@ -181,7 +192,7 @@ class UniverseManager(IUniverseManager):
                 )
 
         # - alter positions
-        self._position_gathering.alter_positions(self._context, exit_targets)
+        self._get_position_gatherer().alter_positions(self._context, exit_targets)
 
         # - if still open positions close them manually
         for instr in instruments:

qubx/emitters/indicator.py

@@ -113,11 +113,17 @@ class IndicatorEmitter(Indicator):
                 emission_tags = self._tags.copy()
 
                 # Emit the metric with the proper timestamp
+                # Convert time to numpy datetime64 if needed
+                if isinstance(time, int):
+                    timestamp = np.datetime64(time, 'ns')
+                else:
+                    timestamp = pd.Timestamp(time).to_datetime64()
+                    
                 self._metric_emitter.emit(
                     name=self._metric_name,
                     value=float(current_value),
                     tags=emission_tags,
-                    timestamp=pd.Timestamp(time),
+                    timestamp=timestamp,
                     instrument=self._instrument,
                 )
 
@@ -134,8 +140,7 @@ class IndicatorEmitter(Indicator):
                     f"from '{self._wrapped_indicator.name}': {e}"
                 )
 
-        # Return the current value
-        return current_value
+        return float(current_value)
 
     @classmethod
     def wrap_with_emitter(

qubx/emitters/questdb.py

@@ -146,7 +146,7 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
             symbols = {"metric_name": name}
             symbols.update(tags)  # Add all tags as symbols
 
-            columns = {"value": round(value, 5)}  # Add the value as a column
+            columns: dict = {"value": round(value, 5)}  # Add the value as a column
 
             # Use the provided timestamp if available, otherwise use current time
             dt_timestamp = self._convert_timestamp(timestamp) if timestamp is not None else datetime.datetime.now()

qubx/restarts/state_resolvers.py

@@ -56,7 +56,7 @@ class StateResolver:
                 # If signs are opposite, close the live position
                 if live_qty * sim_qty < 0:
                     logger.info(f"Closing position for {instrument.symbol} due to opposite direction: {live_qty} -> 0")
-                    ctx.trade(instrument, -live_qty)
+                    ctx.emit_signal(InitializingSignal(time=ctx.time(), instrument=instrument, signal=0.0))
 
                 # If live position is larger than sim position (same direction), reduce it
                 elif abs(live_qty) > abs(sim_qty) and abs(live_qty) > instrument.lot_size:
@@ -64,7 +64,7 @@ class StateResolver:
                     logger.info(
                         f"Reducing position for {instrument.symbol}: {live_qty} -> {sim_qty} (diff: {qty_diff:.4f})"
                     )
-                    ctx.trade(instrument, qty_diff)
+                    ctx.emit_signal(InitializingSignal(time=ctx.time(), instrument=instrument, signal=sim_qty))
 
                 # If sim position is larger or equal (same direction), do nothing
                 else:
@@ -73,7 +73,7 @@ class StateResolver:
             # If the instrument doesn't exist in simulation, close the position
             else:
                 logger.info(f"Closing position for {instrument.symbol} not in simulation: {live_qty} -> 0")
-                ctx.trade(instrument, -live_qty)
+                ctx.emit_signal(InitializingSignal(time=ctx.time(), instrument=instrument, signal=0.0))
 
     @staticmethod
     def CLOSE_ALL(
@@ -108,7 +108,7 @@ class StateResolver:
         for instrument, position in live_positions.items():
             if abs(position.quantity) > instrument.lot_size:
                 logger.info(f"Closing position for {instrument.symbol}: {position.quantity} -> 0")
-                ctx.trade(instrument, -position.quantity)
+                ctx.emit_signal(InitializingSignal(time=ctx.time(), instrument=instrument, signal=0.0))
 
     @staticmethod
     def SYNC_STATE(

qubx/restorers/signal.py

@@ -289,7 +289,7 @@ class MongoDBSignalRestorer(ISignalRestorer):
                     continue
 
                 price = log.get("price") or log.get("reference_price")
-                options = {key: log[key] for key in ["comment", "size", "meta"] if key in log}
+                options = log.get("options", {})
 
                 signal = Signal(
                     time=recognize_time(log["timestamp"]),
@@ -328,7 +328,7 @@ class MongoDBSignalRestorer(ISignalRestorer):
 
                 target_size = float(log["target_position"])
                 price = log.get("entry_price", None)
-                options = {key: log[key] for key in ["comment", "size", "meta"] if key in log}
+                options = log.get("options", {})
 
                 target = TargetPosition(
                     time=recognize_time(log["timestamp"]),

qubx/utils/runner/_jupyter_runner.pyt

@@ -85,13 +85,14 @@ for x in inspect.getmembers(S, (inspect.ismethod)):
 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 def _pos_to_dict(p: Position):
-    mv = round(p.market_value_funds, 3)
+    mv = round(p.notional_value, 3)
     return dict(
-            Position=round(p.quantity, p.instrument.size_precision),  
-            PnL=p.total_pnl(), 
-            AvgPrice=round(p.position_avg_price_funds, p.instrument.price_precision), 
-            LastPrice=round(p.last_update_price, p.instrument.price_precision),
-            MktValue=mv)
+        MktValue=mv,
+        Position=round(p.quantity, p.instrument.size_precision),  
+        PnL=p.total_pnl(), 
+        AvgPrice=round(p.position_avg_price_funds, p.instrument.price_precision), 
+        LastPrice=round(p.last_update_price, p.instrument.price_precision),
+    )
 
 
 class ActiveInstrument:
@@ -195,7 +196,6 @@ def portfolio(all=True):
 
     d = dict()
     for s, p in ctx.get_positions().items():
-        mv = round(p.market_value_funds, 3)
         if p.quantity != 0.0 or all:
             d[dequotify(s.symbol, s.quote)] = _pos_to_dict(p)
 
@@ -205,10 +205,10 @@ def portfolio(all=True):
         print('-(no open positions yet)-')
         return
 
-    d = d.sort_values('PnL' ,ascending=False)
+    d = d.sort_values('MktValue' ,ascending=False)
     # d = pd.concat((d, pd.Series(dict(TOTAL=d['PnL'].sum()), name='PnL'))).fillna('')
     d = pd.concat((d, scols(pd.Series(dict(TOTAL=d['PnL'].sum()), name='PnL'), pd.Series(dict(TOTAL=d['MktValue'].sum()), name='MktValue')))).fillna('')
-    print(tabulate(d, ['Position', 'PnL', 'AvgPrice', 'LastPrice', 'MktValue'], tablefmt='rounded_grid'))
+    print(tabulate(d, ['MktValue', 'Position', 'PnL', 'AvgPrice', 'LastPrice'], tablefmt='rounded_grid'))
 
 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 __exit = exit

qubx/utils/runner/runner.py

@@ -384,6 +384,7 @@ def create_strategy_context(
         initializer=_initializer,
         strategy_name=stg_name,
         health_monitor=_health_monitor,
+        restored_state=restored_state,
     )
 
     return ctx
@@ -509,7 +510,7 @@ def _create_account_processor(
             return get_ccxt_account(
                 exchange_name,
                 account_id=exchange_name,
-                exchange=exchange_manager,
+                exchange_manager=exchange_manager,
                 channel=channel,
                 time_provider=time_provider,
                 base_currency=creds.base_currency,

{qubx-0.6.76.dist-info → qubx-0.6.78.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.76
+Version: 0.6.78
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.76.dist-info → qubx-0.6.78.dist-info}/RECORD

@@ -17,10 +17,10 @@ qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/cli/commands.py,sha256=z1Qs6jLbrfINk7D6V7n6ruPNLoyq3T-sY66Y-F8LmBE,11714
 qubx/cli/deploy.py,sha256=pQ9FPOsywDyy8jOjLfrgYTTkKQ-MCixCzbgsG68Q3_0,8319
 qubx/cli/misc.py,sha256=tP28QxLEzuP8R2xnt8g3JTs9Z7aYy4iVWY4g3VzKTsQ,14777
-qubx/cli/release.py,sha256=7xaCcpUSm6aK_SC_F_YIZl-vYToKWnkaZW-Ik8oBcRs,40435
+qubx/cli/release.py,sha256=Kz5aykF9FlAeUgXF59_Mu3vRFxa_qF9dq0ySqLlKKqo,41362
 qubx/cli/tui.py,sha256=N15UiNEdnWOWYh8E9DNlQCDWdoyP6rMGMhEItogPW88,16491
 qubx/connectors/ccxt/__init__.py,sha256=HEQ7lM9HS8sED_zfsAHrhFT7F9E7NFGAecwZwNr-TDE,65
-qubx/connectors/ccxt/account.py,sha256=HILqsSPfor58NrlP0qYwO5lkNZzUBG-SR5Hy1OSa7_M,24308
+qubx/connectors/ccxt/account.py,sha256=f_Qa3ti5RY6CP3aww04CKvGgc8FYdSOi__FMdscG2y4,24664
 qubx/connectors/ccxt/adapters/__init__.py,sha256=4qwWer4C9fTIZKUYmcgbMFEwFuYp34UKbb-AoQNvXjc,178
 qubx/connectors/ccxt/adapters/polling_adapter.py,sha256=UrOAoIfgtoRw7gj6Bmk5lPs_UI8iOxr88DAfp5o5CF8,8962
 qubx/connectors/ccxt/broker.py,sha256=I6I_BynhwHadKa62nBGmDoj5LhFiEzbUq-1ZDwE25aM,16512
@@ -51,38 +51,38 @@ qubx/connectors/ccxt/handlers/quote.py,sha256=JwQ8mXMpFMdFEpQTx3x_Xaj6VHZanC6_JI
 qubx/connectors/ccxt/handlers/trade.py,sha256=VspCqw13r9SyvF0N3a31YKIVTzUx5IjFtMDaQeSxblM,4519
 qubx/connectors/ccxt/reader.py,sha256=uUG1I_ejzTf0f4bCAHpLhBzTUqtNX-JvJGFA4bi7-WU,26602
 qubx/connectors/ccxt/subscription_config.py,sha256=jbMZ_9US3nvrp6LCVmMXLQnAjXH0xIltzUSPqXJZvgs,3865
-qubx/connectors/ccxt/subscription_manager.py,sha256=ZGWf-j4ZTJm-flhVvCs2kLRGqt0zci3p4PSf4nvTKzI,12662
+qubx/connectors/ccxt/subscription_manager.py,sha256=9ZfA6bR6YwtlZqVs6yymKPvYSvy5x3yBuHA_LDbiKgc,13285
 qubx/connectors/ccxt/subscription_orchestrator.py,sha256=CbZMTRhmgcJZd8cofQbyBDI__N2Lbo1loYfh9_-EkFA,16512
 qubx/connectors/ccxt/utils.py,sha256=ygUHJdhuuSPCvPULEYK05ZuKExbOnDd-dsJ8mEhDDBA,16378
 qubx/connectors/ccxt/warmup_service.py,sha256=a7qSFUmgUm6s7qP-ae9RP-j1bR9XyEsNy4SNOLbPk_c,4893
 qubx/connectors/tardis/data.py,sha256=TlapY1dwc_aQxf4Na9sF620lK9drrg7E9E8gPTGD3FE,31004
 qubx/connectors/tardis/utils.py,sha256=epThu9DwqbDb7BgScH6fHa_FVpKUaItOqp3JwtKGc5g,9092
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/core/account.py,sha256=ZuWhV1_d6jgi7Ry0j1dUDllQ6nO3c4TqcsKQ3lWls0E,22951
+qubx/core/account.py,sha256=HhbxVQ-iozVOGr5uL5ZaBGK8TCZi2KoyTaFu79uX3Oo,23880
 qubx/core/basics.py,sha256=ggK75OsmpH-SCH_Q_2kJmmgFxgrgt4RgO7QipCqUCGk,41301
-qubx/core/context.py,sha256=x-lLDJIZLH93Jtm_KmoG0joVwFGe65GeOUeNQt6Is7Q,25573
+qubx/core/context.py,sha256=Yq039nsKmf-IeyvcRdnMs_phVmehoCUqFvQuVnm-d4s,26074
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
 qubx/core/errors.py,sha256=LENtlgmVzxxUFNCsuy4PwyHYhkZkxuZQ2BPif8jaGmw,1411
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
 qubx/core/helpers.py,sha256=3rY7VkeL8WQ3hj7f8_rbSYNuQftlT0IDpTUARGP5ORM,21622
 qubx/core/initializer.py,sha256=VVti9UJDJCg0125Mm09S6Tt1foHK4XOBL0mXgDmvXes,7724
-qubx/core/interfaces.py,sha256=gSfOsYOlI-TSnt9fMRlO5-amsljq0ID50LPuwiR5HNA,66370
-qubx/core/loggers.py,sha256=pa28UYLTfRibhDzcbtPfbtNb3jpMZ8catTMikA0RFlc,14268
+qubx/core/interfaces.py,sha256=AwSS92BbfUXw92TLvB75Wn5bxYByHAAXie2GAC70vUQ,67824
+qubx/core/loggers.py,sha256=eYijsR02S5u1Hv21vjIk_dOUwOMv0fiBDYwEmFhAoWk,14344
 qubx/core/lookups.py,sha256=Bed30kPZvbTGjZ8exojhIMOIVfB46j6741yF3fXGTiM,18313
 qubx/core/metrics.py,sha256=eMsg9qaL86pkKVKrQOyF9u7yf27feLRxOvJj-6qwmj8,75551
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
 qubx/core/mixins/market.py,sha256=w9OEDfy0r9xnb4KdKA-PuFsCQugNo4pMLQivGFeyqGw,6356
-qubx/core/mixins/processing.py,sha256=OgmrQfnUQKfHJ77BYrXQIu4AOz3xGlnuP8H6UvCiWhA,42216
+qubx/core/mixins/processing.py,sha256=UqKwOzkDXvmcjvffrsR8vugq_XacwW9rcGM0TcBd9RM,44485
 qubx/core/mixins/subscription.py,sha256=GcZKHHzjPyYFLAEpE7j4fpLDOlAhFKojQEYfFO3QarY,11064
-qubx/core/mixins/trading.py,sha256=zq3JO8UDwbkYgmTHy1W8Ccn9Adeo1xw3vnyFAUFU0R4,9047
-qubx/core/mixins/universe.py,sha256=mzZJA7Me6HNFbAMGg1XOpnYCMtcFKHESTiozjaXyKXY,10100
+qubx/core/mixins/trading.py,sha256=7KwxHiPWkXGnkHS4VLaxOZ7BHULkvvqPS8ooAG1NTxM,9477
+qubx/core/mixins/universe.py,sha256=UBa3OIr2XvlK04O7YUG9c66CY8AZ5rQDSZov1rnUSjQ,10512
 qubx/core/mixins/utils.py,sha256=P71cLuqKjId8989MwOL_BtvvCnnwOFMkZyB1SY-0Ork,147
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=9cTUv-67TypYnfAjnTnUKc8tPt_ZMWXqoD2woFM7g3E,1019592
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=0FPkdICMQaAvcLrcuMIV9RjdbyaD7Hq987H2awwlSiI,1019592
 qubx/core/series.pxd,sha256=PvnUEupOsZg8u81U5Amd-nbfmWQ0-PwZwc7yUoaZpoQ,4739
 qubx/core/series.pyi,sha256=RkM-F3AyrzT7m1H2UmOvZmmcOzU2eBeEWf2c0GUZe2o,5437
 qubx/core/series.pyx,sha256=wAn7L9HIkvVl-1Tt7bgdWhec7xy4AiHSXyDsrA4a29U,51703
 qubx/core/stale_data_detector.py,sha256=NHnnG9NkcivC93n8QMwJUzFVQv2ziUaN-fg76ppng_c,17118
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=SV1zNlv2BM1i-AaCyL7crSn6YNXDew_zG87n0ZoCXIk,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=yUmHzn-JTnvLybsw6nMLz-05T-4ITjc9H1EWNVFKQes,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=UR9achMR-LARsztd2eelFsDsFH3n0gXACIKoGNPI9X4,1766
 qubx/data/__init__.py,sha256=BlyZ99esHLDmFA6ktNkuIce9RZO99TA1IMKWe94aI8M,599
@@ -96,10 +96,10 @@ qubx/emitters/__init__.py,sha256=MPs7ZRZZnURljusiuvlO5g8M4H1UjEfg5fkyKeJmIBI,791
 qubx/emitters/base.py,sha256=lxNmP81pXuRo0LKjjxkGqn0LCYjWDiqJ94dQdosGugg,8744
 qubx/emitters/composite.py,sha256=JkFch4Tp5q6CaLU2nAmeZnRiVPGkFhGNvzhT255yJfI,3411
 qubx/emitters/csv.py,sha256=S-oQ84rCgP-bb2_q-FWcegACg_Ej_Ik3tXE6aJBlqOk,4963
-qubx/emitters/indicator.py,sha256=4f5E9q8ofzQijJuaupRUpgVfq6fquzpa8sdNLtQJrlM,7972
+qubx/emitters/indicator.py,sha256=NlhXJAZCboUDz7M7MOjfiR-ASM_L5qv0KgPJE-ekQCY,8206
 qubx/emitters/inmemory.py,sha256=AsFpAGGTWQsv42H5-3tDeZ3XP9b5Ye7lFHis53qcdjs,8862
 qubx/emitters/prometheus.py,sha256=lZJ_Hl-AlkeWJmktxhAiEMiTIc8dTQvBpf3Ih5Fy6pE,10516
-qubx/emitters/questdb.py,sha256=Zc4Vbr9g7Pw9oRSEnPnA1ypDv6nRwUEYAOrT-FFYFos,11526
+qubx/emitters/questdb.py,sha256=hGneKVEnkV82t7c9G3_uVEgAoN302nXBSjjCWHKnAv0,11532
 qubx/exporters/__init__.py,sha256=7HeYHCZfKAaBVAByx9wE8DyGv6C55oeED9uUphcyjuc,360
 qubx/exporters/composite.py,sha256=c45XcMC0dsIDwOyOxxCuiyYQjUNhqPjptAulbaSqttU,2973
 qubx/exporters/formatters/__init__.py,sha256=La9rMsl3wyplza0xVyAFrUwhFyrGDIMJWmOB_boJyIg,488
@@ -145,18 +145,18 @@ qubx/resources/instruments/symbols-kraken-spot.json,sha256=3JLxi18nQAXE5J73hFY-m
 qubx/resources/instruments/symbols-kraken.f-future.json,sha256=FzOg8KIcl4nBQdPqugc-dMHxXGvyiQncNAHs84Tf4Pg,247468
 qubx/resources/instruments/symbols-kraken.f-perpetual.json,sha256=a1xXqbEcOyL1NLQO2JsSsseezPP7QCB9dub4IQhRviE,177233
 qubx/restarts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/restarts/state_resolvers.py,sha256=n9c85uMlqwbtQ63eMJFdfnzmJx195rUhCB8VVc-Xe2Y,7539
+qubx/restarts/state_resolvers.py,sha256=_MpcCqHL0_NL1A3CC9iKIwVffkjMHj6QJir3jQGrG10,7755
 qubx/restarts/time_finders.py,sha256=AX0Hb-RvB4YSot6L5m1ylkj09V7TYYXFvKgdb8gj0ok,4307
 qubx/restorers/__init__.py,sha256=vrnZBPJHR0-6knAccj4bK0tkjUPNRl32qiLr5Mv4aR0,911
 qubx/restorers/balance.py,sha256=yLV1vBki0XhBxrOhgaJBHuuL8VmIii82LAWgLxusbcE,6967
 qubx/restorers/factory.py,sha256=hQz3MRI7OH3SyMK1RjSuneb2ImJ_oWX0WSpu0tgJUug,6743
 qubx/restorers/interfaces.py,sha256=TsfdtcMUMncB6Cit_k66lEe5YKzVdVKpU68FXtZL-qY,1932
 qubx/restorers/position.py,sha256=jMJjq2ZJwHpAlG45bMy49WvkYK5UylDiExt7nVpxCfg,8703
-qubx/restorers/signal.py,sha256=7n7eeRhWGUBPbg179GxFH_ifywcl3pQJbwrcDklw0N0,14604
+qubx/restorers/signal.py,sha256=5nK5ji8AucyWrFBK9uW619YCI_vPRGFnuDu8JnG3B_Y,14512
 qubx/restorers/state.py,sha256=I1VIN0ZcOjigc3WMHIYTNJeAAbN9YB21MDcMl04ZWmY,8018
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=ZcmtCMbF7wgX0bnTW5bOKfsQJT9M-yZjvS9rSSWqJ2A,762760
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=xwgp8UOeeixa0CdddHwS_emo-39gCZ6TRSlI2u3ER8s,762760
 qubx/ta/indicators.pxd,sha256=l4JgvNdlWBuLqMzqTZVaYYn4XyZ9-c222YCyBXVv8MA,4843
 qubx/ta/indicators.pyi,sha256=kHoHONhzI7aq0qs-wP5cxyDPj96ZvQLlThEC8yQj6U4,2630
 qubx/ta/indicators.pyx,sha256=rT6OJ7xygZdTF4-pT6vr6g9MRhvbi6nYBlkTzzZYA_U,35126
@@ -204,15 +204,15 @@ qubx/utils/plotting/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 qubx/utils/plotting/renderers/plotly.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/utils/questdb.py,sha256=bxlWiCyYf8IspsvXrs58tn5iXYBUtv6ojeYwOj8EXI0,5269
 qubx/utils/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/utils/runner/_jupyter_runner.pyt,sha256=1bo06ql_wlZ7ng6go_zvemySzngrM8Uqzj-_xeOdiFg,10030
+qubx/utils/runner/_jupyter_runner.pyt,sha256=DHXhXkjHe8-HkOa4g5EkSb3qbz64TLyM3-c__cQDPjk,9973
 qubx/utils/runner/accounts.py,sha256=mpiv6oxr5z97zWt7STYyARMhWQIpc_XFKungb_pX38U,3270
 qubx/utils/runner/configs.py,sha256=X915N6wbRSPFBiZ3WZcNQBSeoiocy-wVxCTTSdM8IAo,5367
 qubx/utils/runner/factory.py,sha256=hmtUDYNFQwVQffHEfxgrlmKwOGLcFQ6uJIH_ZLscpIY,16347
-qubx/utils/runner/runner.py,sha256=T2V6KSKcLNQVXYjxw4zrF7n_AhKEuHJBXjFGU0u1DQY,33252
+qubx/utils/runner/runner.py,sha256=gZvj-ScJkSnbl7Vj3VENfdiruc5eCTzUkKek3zPmXiM,33299
 qubx/utils/time.py,sha256=xOWl_F6dOLFCmbB4xccLIx5yVt5HOH-I8ZcuowXjtBQ,11797
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.76.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.76.dist-info/METADATA,sha256=SPvvMbuvPf7wuoJ0fT_ZqBkx-yemYwZhJHpl4znfJ6s,5836
-qubx-0.6.76.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.76.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.76.dist-info/RECORD,,
+qubx-0.6.78.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.78.dist-info/METADATA,sha256=MdOcTFxgH5pUTsBloOTFMxpzZI3envIgDT7VrUzkOyE,5836
+qubx-0.6.78.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.78.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.78.dist-info/RECORD,,