Qubx 0.6.77__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.84__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/management.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import numpy as np
 import pandas as pd
 import yaml
+from tqdm.auto import tqdm
 
 from qubx.core.metrics import TradingSessionResult
 from qubx.utils.misc import blue, cyan, green, magenta, red, yellow
@@ -420,8 +421,10 @@ class BacktestsResultsManager:
         Returns:
             plotly.graph_objects.Figure: The plot of the variation.
         """
-        import plotly.express as px
         from itertools import cycle
+
+        import plotly.express as px
+
         from qubx.utils.misc import string_shortener
 
         _vars = self.variations.get(variation_idx)
@@ -507,3 +510,11 @@ class BacktestsResultsManager:
             )
         )
         return figure
+
+    def export_backtests_to_markdown(self, path: str, tags: tuple[str] | None = None):
+        """
+        Export backtests to markdown format
+        """
+        for n, v in tqdm(self.results.items()):
+            r = TradingSessionResult.from_file(v.get("path"))
+            r.to_markdown(path, list(tags) if tags else None)

qubx/backtester/runner.py

@@ -15,6 +15,7 @@ from qubx.core.helpers import extract_parameters_from_object, full_qualified_cla
 from qubx.core.initializer import BasicStrategyInitializer
 from qubx.core.interfaces import (
     CtrlChannel,
+    IDataProvider,
     IMetricEmitter,
     IStrategy,
     IStrategyContext,
@@ -224,7 +225,7 @@ class SimulationRunner:
         cc = self.channel
         t = np.datetime64(data.time, "ns")
         _account = self.account.get_account_processor(instrument.exchange)
-        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        _data_provider = self._get_data_provider(instrument.exchange)
         assert isinstance(_account, SimulatedAccountProcessor)
         assert isinstance(_data_provider, SimulatedDataProvider)
 
@@ -249,7 +250,7 @@ class SimulationRunner:
         cc = self.channel
         t = np.datetime64(data.time, "ns")
         _account = self.account.get_account_processor(instrument.exchange)
-        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        _data_provider = self._get_data_provider(instrument.exchange)
         assert isinstance(_account, SimulatedAccountProcessor)
         assert isinstance(_data_provider, SimulatedDataProvider)
 
@@ -267,6 +268,11 @@ class SimulationRunner:
 
         return cc.control.is_set()
 
+    def _get_data_provider(self, exchange: str) -> IDataProvider:
+        if exchange in self._exchange_to_data_provider:
+            return self._exchange_to_data_provider[exchange]
+        raise ValueError(f"Data provider for exchange {exchange} not found")
+
     def _run(self, start: pd.Timestamp, stop: pd.Timestamp, silent: bool = False) -> None:
         logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
 
@@ -328,7 +334,7 @@ class SimulationRunner:
 
         if not _run(instrument, data_type, event, is_hist):
             return False
-        
+
         return True
 
     def _handle_no_data_scenario(self, stop_time):

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

@@ -82,6 +82,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         open_order_backoff: str = "1Min",
         max_position_restore_days: int = 5,
         max_retries: int = 10,
+        connection_timeout: int = 30,
         read_only: bool = False,
     ):
         super().__init__(
@@ -109,6 +110,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self._latest_instruments = set()
         self._subscription_manager = None
         self._read_only = read_only
+        self._connection_timeout = connection_timeout
 
     def set_subscription_manager(self, manager: ISubscriptionManager) -> None:
         self._subscription_manager = manager
@@ -172,6 +174,14 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         super().update_position_price(time, instrument, update)
 
     def get_total_capital(self, exchange: str | None = None) -> float:
+        # If polling is not running yet, we need to fetch balance data directly
+        if not self._is_running and self.exchange_manager.exchange:
+            try:
+                future = self._loop.submit(self._update_balance())
+                future.result(timeout=self._connection_timeout)
+            except Exception as e:
+                logger.warning(f"Failed to fetch balance data before polling started: {e}")
+
         # sum of balances + market value of all positions on non spot/margin
         _currency_to_value = {c: self._get_currency_value(b.total, c) for c, b in self._balances.items()}
         _positions_value = sum([p.market_value_funds for p in self._positions.values() if p.instrument.is_futures()])
@@ -294,7 +304,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _update_positions(self) -> None:
         # fetch and update positions from exchange
         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
+        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
@@ -458,7 +470,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
             async def _cancel_order(order: Order) -> None:
                 try:
-                    await self.exchange_manager.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})"
                     )
@@ -476,7 +490,9 @@ 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_manager.exchange.fetch_open_orders if is_open else self.exchange_manager.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}
@@ -533,7 +549,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         async def _watch_executions():
             exec = await self.exchange_manager.exchange.watch_orders()
             for report in exec:
-                instrument = ccxt_find_instrument(report["symbol"], self.exchange_manager.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))

qubx/connectors/ccxt/exchange_manager.py

@@ -24,12 +24,13 @@ SECONDS_PER_HOUR = 3600
 
 # Custom stall detection thresholds (in seconds)
 STALL_THRESHOLDS = {
-    'funding_payment': 12 * SECONDS_PER_HOUR,    # 12 hours = 43,200s
-    'open_interest': 30 * 60,                    # 30 minutes = 1,800s
-    'orderbook': 5 * 60,                         # 5 minutes = 300s
-    'trade': 60 * 60,                            # 60 minutes = 3,600s
-    'liquidation': 7 * 24 * SECONDS_PER_HOUR,    # 7 days = 604,800s
-    'ohlc': 15 * 60,                             # 15 minutes = 900s
+    "funding_payment": 12 * SECONDS_PER_HOUR,  # 12 hours = 43,200s
+    "open_interest": 30 * 60,  # 30 minutes = 1,800s
+    "orderbook": 5 * 60,  # 5 minutes = 300s
+    "trade": 60 * 60,  # 60 minutes = 3,600s
+    "liquidation": 7 * 24 * SECONDS_PER_HOUR,  # 7 days = 604,800s
+    "ohlc": 5 * 60,  # 5 minutes = 300s
+    "quote": 5 * 60,  # 5 minutes = 300s
 }
 DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 
@@ -37,10 +38,10 @@ DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 class ExchangeManager(IDataArrivalListener):
     """
     Wrapper for CCXT Exchange that handles recreation internally with self-monitoring.
-    
+
     Exposes the underlying exchange via .exchange property for explicit access.
     Self-monitors for data stalls and triggers recreation automatically.
-    
+
     Key Features:
     - Explicit .exchange property for CCXT access
     - Self-contained stall detection and recreation triggering
@@ -48,7 +49,7 @@ class ExchangeManager(IDataArrivalListener):
     - Atomic exchange transitions during recreation
     - Background monitoring thread for stall detection
     """
-    
+
     _exchange: cxp.Exchange  # Type hint that this is always a valid exchange
 
     def __init__(
@@ -61,10 +62,10 @@ class ExchangeManager(IDataArrivalListener):
         check_interval_seconds: float = DEFAULT_CHECK_INTERVAL_SECONDS,
     ):
         """Initialize ExchangeManager with underlying CCXT exchange.
-        
+
         Args:
             exchange_name: Exchange name for factory (e.g., "binance.um")
-            factory_params: Parameters for get_ccxt_exchange() 
+            factory_params: Parameters for get_ccxt_exchange()
             initial_exchange: Pre-created exchange instance (from factory)
             max_recreations: Maximum recreation attempts before giving up
             reset_interval_hours: Hours between recreation count resets
@@ -74,24 +75,24 @@ class ExchangeManager(IDataArrivalListener):
         self._factory_params = factory_params.copy()
         self._max_recreations = max_recreations
         self._reset_interval_hours = reset_interval_hours
-        
+
         # Recreation state
         self._recreation_count = 0
         self._recreation_lock = threading.RLock()
         self._last_successful_reset = time.time()
-        
+
         # Stall detection state
         self._check_interval = check_interval_seconds
         self._last_data_times: dict[str, float] = {}
         self._data_lock = threading.RLock()
-        
+
         # Monitoring control
         self._monitoring_enabled = False
         self._monitor_thread = None
-        
+
         # Recreation callback management
         self._recreation_callbacks: list[Callable[[], None]] = []
-        
+
         # Use provided exchange or create new one
         if initial_exchange:
             self._exchange = initial_exchange
@@ -105,23 +106,23 @@ class ExchangeManager(IDataArrivalListener):
         try:
             # Import here to avoid circular import (factory → broker → exchange_manager)
             from .factory import get_ccxt_exchange
-            
+
             # Create raw exchange using factory logic
             ccxt_exchange = get_ccxt_exchange(**self._factory_params)
-            
+
             # Setup exception handler for the new exchange
             self._setup_ccxt_exception_handler(ccxt_exchange)
-            
+
             logger.debug(f"Created new {self._exchange_name} exchange instance")
             return ccxt_exchange
-            
+
         except Exception as e:
             logger.error(f"Failed to create {self._exchange_name} exchange: {e}")
             raise RuntimeError(f"Failed to create {self._exchange_name} exchange: {e}") from e
-    
+
     def register_recreation_callback(self, callback: Callable[[], None]) -> None:
         """Register callback to be called after successful exchange recreation.
-        
+
         Args:
             callback: Function to call after successful recreation (no parameters)
         """
@@ -131,7 +132,7 @@ class ExchangeManager(IDataArrivalListener):
     def _call_recreation_callbacks(self) -> None:
         """Call all registered recreation callbacks after successful exchange recreation."""
         logger.debug(f"Calling {len(self._recreation_callbacks)} recreation callbacks for {self._exchange_name}")
-        
+
         for callback in self._recreation_callbacks:
             try:
                 callback()
@@ -142,66 +143,68 @@ class ExchangeManager(IDataArrivalListener):
     def force_recreation(self) -> bool:
         """
         Force recreation due to data stalls (called by BaseHealthMonitor).
-        
+
         Returns:
             True if recreation successful, False if failed/limit exceeded
         """
         with self._recreation_lock:
             # Check recreation limit
             if self._recreation_count >= self._max_recreations:
-                logger.error(f"Cannot recreate {self._exchange_name}: recreation limit ({self._max_recreations}) exceeded")
+                logger.error(
+                    f"Cannot recreate {self._exchange_name}: recreation limit ({self._max_recreations}) exceeded"
+                )
                 return False
-            
+
             logger.info(f"Stall-triggered recreation for {self._exchange_name}")
             return self._recreate_exchange()
-    
+
     def _recreate_exchange(self) -> bool:
         """Recreate the underlying exchange (must be called with _recreation_lock held)."""
         self._recreation_count += 1
-        logger.warning(f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count}/{self._max_recreations})")
-        
+        logger.warning(
+            f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count}/{self._max_recreations})"
+        )
+
         # Create new exchange
         try:
             new_exchange = self._create_exchange()
         except Exception as e:
             logger.error(f"Failed to recreate {self._exchange_name} exchange: {e}")
             return False
-            
+
         # Atomically replace the exchange
         old_exchange = self._exchange
         self._exchange = new_exchange
-        
+
         # Clean up old exchange
         try:
-            if hasattr(old_exchange, 'close') and hasattr(old_exchange, 'asyncio_loop'):
-                old_exchange.asyncio_loop.call_soon_threadsafe(
-                    lambda: asyncio.create_task(old_exchange.close())
-                )
+            if hasattr(old_exchange, "close") and hasattr(old_exchange, "asyncio_loop"):
+                old_exchange.asyncio_loop.call_soon_threadsafe(lambda: asyncio.create_task(old_exchange.close()))
         except Exception as e:
             logger.warning(f"Error closing old {self._exchange_name} exchange: {e}")
-        
+
         logger.info(f"Successfully recreated {self._exchange_name} exchange")
-        
+
         # Call recreation callbacks after successful recreation
         self._call_recreation_callbacks()
-        
+
         return True
-        
+
     def reset_recreation_count_if_needed(self) -> None:
         """Reset recreation count periodically (called by monitoring loop)."""
         reset_interval_seconds = self._reset_interval_hours * SECONDS_PER_HOUR
-        
+
         current_time = time.time()
         time_since_reset = current_time - self._last_successful_reset
-        
+
         if time_since_reset >= reset_interval_seconds and self._recreation_count > 0:
             logger.info(f"Resetting recreation count for {self._exchange_name} (was {self._recreation_count})")
             self._recreation_count = 0
             self._last_successful_reset = current_time
-    
+
     def on_data_arrival(self, event_type: str, event_time: dt_64) -> None:
         """Record data arrival for stall detection.
-        
+
         Args:
             event_type: Type of data event (e.g., "ohlcv", "trade", "orderbook")
             event_time: Timestamp of the data event (unused for stall detection)
@@ -209,10 +212,10 @@ class ExchangeManager(IDataArrivalListener):
         current_timestamp = time.time()
         with self._data_lock:
             self._last_data_times[event_type] = current_timestamp
-    
+
     def _extract_ohlc_timeframe(self, event_type: str) -> Optional[str]:
         """Extract timeframe from OHLC event type like 'ohlc(1m)' -> '1m'."""
-        if event_type.startswith('ohlc(') and event_type.endswith(')'):
+        if event_type.startswith("ohlc(") and event_type.endswith(")"):
             return event_type[5:-1]  # Simple slice: ohlc(1m) -> 1m
         return None
 
@@ -222,30 +225,30 @@ class ExchangeManager(IDataArrivalListener):
 
     def _get_stall_threshold(self, event_type: str) -> float:
         """Get stall threshold for specific event type.
-        
+
         Extracts base data type from parameterized types like 'ohlc(1m)' -> 'ohlc'.
         """
         # Extract base data type (everything before first '(' if present)
-        base_event_type = event_type.split('(')[0]
+        base_event_type = event_type.split("(")[0]
         return float(STALL_THRESHOLDS.get(base_event_type, DEFAULT_STALL_THRESHOLD_SECONDS))
-            
+
     def start_monitoring(self) -> None:
         """Start background stall detection monitoring."""
         if self._monitoring_enabled:
             return
-            
+
         self._monitoring_enabled = True
         self._monitor_thread = threading.Thread(target=self._stall_monitor_loop, daemon=True)
         self._monitor_thread.start()
         logger.debug(f"ExchangeManager: Started stall monitoring for {self._exchange_name}")
-        
+
     def stop_monitoring(self) -> None:
         """Stop background stall detection monitoring."""
         self._monitoring_enabled = False
         if self._monitor_thread:
             self._monitor_thread = None
         logger.debug(f"ExchangeManager: Stopped stall monitoring for {self._exchange_name}")
-        
+
     def _stall_monitor_loop(self) -> None:
         """Background thread that checks for data stalls and triggers self-recreation."""
         while self._monitoring_enabled:
@@ -256,26 +259,26 @@ class ExchangeManager(IDataArrivalListener):
             except Exception as e:
                 logger.error(f"Error in ExchangeManager stall detection: {e}")
                 time.sleep(self._check_interval)
-                
+
     def _check_and_handle_stalls(self) -> None:
         """Check for stalls using custom thresholds per data type."""
         current_time = time.time()
         stalled_types = []
-        
+
         with self._data_lock:
             for event_type, last_data_time in self._last_data_times.items():
                 time_since_data = current_time - last_data_time
                 threshold = self._get_stall_threshold(event_type)
-                
+
                 if time_since_data > threshold:
                     stalled_types.append((event_type, time_since_data))
-                    
+
         if not stalled_types:
             return  # No stalls detected
-            
+
         stall_info = ", ".join([f"{event_type}({int(time_since)}s)" for event_type, time_since in stalled_types])
         logger.error(f"Data stalls detected in {self._exchange_name}: {stall_info}")
-        
+
         try:
             logger.info(f"Self-triggering recreation for {self._exchange_name} due to stalls...")
             if self.force_recreation():
@@ -288,14 +291,14 @@ class ExchangeManager(IDataArrivalListener):
                 logger.error(f"Stall-triggered recreation failed for {self._exchange_name}")
         except Exception as e:
             logger.error(f"Error during stall-triggered recreation: {e}")
-    
+
     def _setup_ccxt_exception_handler(self, exchange: cxp.Exchange) -> None:
         """
         Set up global exception handler for the CCXT async loop to handle unretrieved futures.
 
         This prevents 'Future exception was never retrieved' warnings from CCXT's internal
         per-symbol futures that complete with UnsubscribeError during resubscription.
-        
+
         Applied to every newly created exchange (initial and recreated).
         """
         asyncio_loop = exchange.asyncio_loop
@@ -324,15 +327,15 @@ class ExchangeManager(IDataArrivalListener):
         # Set the custom exception handler on the CCXT loop
         asyncio_loop.set_exception_handler(handle_ccxt_exception)
 
-    # === Exchange Property Access === 
+    # === Exchange Property Access ===
     # Explicit property to access underlying CCXT exchange
-    
+
     @property
     def exchange(self) -> cxp.Exchange:
         """Access to the underlying CCXT exchange instance.
-        
+
         Use this property to call CCXT methods: exchange_manager.exchange.fetch_ticker(symbol)
-        
+
         Returns:
             The current CCXT exchange instance (may change after recreation)
         """

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):
@@ -343,7 +344,8 @@ class CompositeAccountProcessor(IAccountProcessor):
             raise ValueError("At least one account processor must be provided")
 
     def get_account_processor(self, exchange: str) -> IAccountProcessor:
-        return self._account_processors[exchange]
+        exch = self._get_exchange(exchange)
+        return self._account_processors[exch]
 
     def _get_exchange(self, exchange: str | None = None, instrument: Instrument | None = None) -> str:
         """
@@ -356,11 +358,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
 

qubx/core/basics.py

@@ -63,6 +63,10 @@ class FundingPayment:
         if self.funding_interval_hours <= 0:
             raise ValueError(f"Invalid funding interval: {self.funding_interval_hours} (must be positive)")
 
+    @property
+    def funding_rate_apr(self) -> float:
+        return self.funding_rate * 365 * 24 / self.funding_interval_hours * 100
+
 
 @dataclass
 class OpenInterest: