Qubx 0.6.76__tar.gz → 0.6.78__tar.gz

{qubx-0.6.76 → qubx-0.6.78}/PKG-INFO

@@ -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 → qubx-0.6.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.76"
+version = "0.6.78"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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-0.6.76 → qubx-0.6.78}/src/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
         ]