Qubx 0.6.62__tar.gz → 0.6.64__tar.gz

{qubx-0.6.62 → qubx-0.6.64}/PKG-INFO

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

{qubx-0.6.62 → qubx-0.6.64}/pyproject.toml

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

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/backtester/data.py

@@ -68,6 +68,10 @@ class SimulatedDataProvider(IDataProvider):
 
         # - provide historical data and last quote for subscribed instruments
         for i in _new_instr:
+            # Check if the instrument was actually subscribed (not filtered out)
+            if not self.has_subscription(i, subscription_type):
+                continue
+                
             h_data = self._data_source.peek_historical_data(i, subscription_type)
             if h_data:
                 # _s_type = DataType.from_str(subscription_type)[0]
@@ -119,7 +123,7 @@ class SimulatedDataProvider(IDataProvider):
         end = start - nbarsback * (_timeframe := pd.Timedelta(timeframe))
         _spec = f"{instrument.exchange}:{instrument.symbol}"
         return self._convert_records_to_bars(
-            _reader.read(data_id=_spec, start=start, stop=end, transform=AsDict()),  # type: ignore
+            _reader.read(data_id=_spec, start=start, stop=end, timeframe=timeframe, transform=AsDict()),  # type: ignore
             time_as_nsec(self.time_provider.time()),
             _timeframe.asm8.item(),
         )

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/backtester/ome.py

@@ -6,17 +6,17 @@ from sortedcontainers import SortedDict
 
 from qubx import logger
 from qubx.core.basics import (
+    OPTION_AVOID_STOP_ORDER_PRICE_VALIDATION,
     OPTION_FILL_AT_SIGNAL_PRICE,
     OPTION_SIGNAL_PRICE,
     OPTION_SKIP_PRICE_CROSS_CONTROL,
-    OPTION_AVOID_STOP_ORDER_PRICE_VALIDATION,
     Deal,
     Instrument,
     ITimeProvider,
     Order,
     OrderSide,
-    OrderType,
     OrderStatus,
+    OrderType,
     TransactionCostsCalculator,
     dt_64,
 )
@@ -208,7 +208,9 @@ class OrdersManagementEngine:
         **options,
     ) -> SimulatedExecutionReport:
         if self.bbo is None:
-            raise ExchangeError(f"Simulator is not ready for order management - no quote for {self.instrument.symbol}")
+            raise SimulationError(
+                f"Simulator is not ready for order management - no quote for {self.instrument.symbol}"
+            )
 
         # - validate order parameters
         self._validate_order(order_side, order_type, amount, price, time_in_force, options)

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/backtester/simulated_data.py

@@ -3,11 +3,12 @@ from typing import Any, Iterator
 import pandas as pd
 
 from qubx import logger
-from qubx.core.basics import DataType, Instrument, Timestamped
+from qubx.core.basics import DataType, Instrument, MarketType, Timestamped
 from qubx.core.exceptions import SimulationError
 from qubx.data.composite import IteratedDataStreamsSlicer
 from qubx.data.readers import (
     AsDict,
+    AsFundingPayments,
     AsOrderBook,
     AsQuotes,
     AsTrades,
@@ -87,6 +88,11 @@ class DataFetcher:
                 self._producing_data_type = "orderbook"
                 self._transformer = AsOrderBook()
 
+            case DataType.FUNDING_PAYMENT:
+                self._requested_data_type = "funding_payment"
+                self._producing_data_type = "funding_payment"
+                self._transformer = AsFundingPayments()
+
             case _:
                 self._requested_data_type = subtype
                 self._producing_data_type = subtype
@@ -250,9 +256,45 @@ class IterableSimulationData(Iterator):
                 _access_key = f"{_subtype}"
         return _access_key, _subtype, _params
 
+    def _filter_instruments_for_subscription(self, data_type: str, instruments: list[Instrument]) -> list[Instrument]:
+        """
+        Filter instruments based on subscription type requirements.
+        
+        For funding payment subscriptions, only SWAP instruments are supported since
+        funding payments are specific to perpetual swap contracts.
+        
+        Args:
+            data_type: The data type being subscribed to
+            instruments: List of instruments to filter
+            
+        Returns:
+            Filtered list of instruments appropriate for the subscription type
+        """
+        # Only funding payments require special filtering
+        if data_type == DataType.FUNDING_PAYMENT:
+            original_count = len(instruments)
+            filtered_instruments = [i for i in instruments if i.market_type == MarketType.SWAP]
+            filtered_count = len(filtered_instruments)
+            
+            # Log if instruments were filtered out (debug info)
+            if filtered_count < original_count:
+                logger.debug(f"Filtered {original_count - filtered_count} non-SWAP instruments from funding payment subscription")
+            
+            return filtered_instruments
+        
+        # For all other subscription types, return instruments unchanged
+        return instruments
+
     def add_instruments_for_subscription(self, subscription: str, instruments: list[Instrument] | Instrument):
         instruments = instruments if isinstance(instruments, list) else [instruments]
         _subt_key, _data_type, _params = self._parse_subscription_spec(subscription)
+        
+        # Filter instruments based on subscription type requirements
+        instruments = self._filter_instruments_for_subscription(_data_type, instruments)
+        
+        # If no instruments remain after filtering, skip subscription
+        if not instruments:
+            return
 
         fetcher = self._subtyped_fetchers.get(_subt_key)
         if not fetcher:

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/backtester/simulator.py

@@ -4,12 +4,12 @@ import pandas as pd
 from joblib import delayed
 
 from qubx import QubxLogConfig, logger
+from qubx.core.basics import Instrument
 from qubx.core.exceptions import SimulationError
 from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
+from qubx.emitters.inmemory import InMemoryMetricEmitter
 from qubx.utils.misc import ProgressParallel, Stopwatch, get_current_user
-from qubx.utils.runner.configs import EmissionConfig
-from qubx.utils.runner.factory import create_metric_emitters
 from qubx.utils.time import handle_start_stop
 
 from .runner import SimulationRunner
@@ -31,11 +31,11 @@ def simulate(
     strategies: StrategiesDecls_t,
     data: DataDecls_t,
     capital: float | dict[str, float],
-    instruments: list[SymbolOrInstrument_t] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
+    instruments: list[str] | list[Instrument] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
     commissions: str | dict[str, str | None] | None,
     start: str | pd.Timestamp,
     stop: str | pd.Timestamp | None = None,
-    exchange: ExchangeName_t | None = None,
+    exchange: ExchangeName_t | list[ExchangeName_t] | None = None,
     base_currency: str = "USDT",
     n_jobs: int = 1,
     silent: bool = False,
@@ -47,7 +47,8 @@ def simulate(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
     run_separate_instruments: bool = False,
 ) -> list[TradingSessionResult]:
     """
@@ -73,7 +74,8 @@ def simulate(
         - show_latency_report: If True, shows simulator's latency report.
         - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
         - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
-        - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
+        - enable_inmemory_emitter (bool): If True, attaches an in-memory metric emitter and returns its dataframe in TradingSessionResult.emitter_data.
+        - emitter_stats_interval (str): Interval for emitting stats in the in-memory emitter (default: "1h").
         - run_separate_instruments (bool): If True, creates separate simulation setups for each instrument, default is False.
 
     Returns:
@@ -143,7 +145,8 @@ def simulate(
         show_latency_report=show_latency_report,
         portfolio_log_freq=portfolio_log_freq,
         parallel_backend=parallel_backend,
-        emission=emission,
+        enable_inmemory_emitter=enable_inmemory_emitter,
+        emitter_stats_interval=emitter_stats_interval,
     )
 
 
@@ -157,7 +160,8 @@ def _run_setups(
     show_latency_report: bool = False,
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -179,7 +183,8 @@ def _run_setups(
                 silent,
                 show_latency_report,
                 portfolio_log_freq,
-                emission,
+                enable_inmemory_emitter,
+                emitter_stats_interval,
             )
             for id, setup in enumerate(strategies_setups)
         ]
@@ -197,7 +202,8 @@ def _run_setups(
                 silent,
                 show_latency_report,
                 portfolio_log_freq,
-                emission,
+                enable_inmemory_emitter,
+                emitter_stats_interval,
             )
             for id, setup in enumerate(strategies_setups)
         )
@@ -223,14 +229,14 @@ def _run_setup(
     silent: bool,
     show_latency_report: bool,
     portfolio_log_freq: str,
-    emission: EmissionConfig | None = None,
+    enable_inmemory_emitter: bool = False,
+    emitter_stats_interval: str = "1h",
 ) -> TradingSessionResult | None:
     try:
-        # Create metric emitter if configured
         emitter = None
-        if emission is not None:
-            emitter = create_metric_emitters(emission, setup.name)
-
+        emitter_data = None
+        if enable_inmemory_emitter:
+            emitter = InMemoryMetricEmitter(stats_interval=emitter_stats_interval)
         runner = SimulationRunner(
             setup=setup,
             data_config=data_setup,
@@ -258,6 +264,9 @@ def _run_setup(
             # Filter out None values to match TradingSessionResult expected type
             commissions_for_result = {k: v for k, v in commissions_for_result.items() if v is not None}
 
+        if enable_inmemory_emitter and emitter is not None:
+            emitter_data = emitter.get_dataframe()
+
         return TradingSessionResult(
             setup_id,
             setup.name,
@@ -276,6 +285,7 @@ def _run_setup(
             parameters=runner.strategy_params,
             is_simulation=True,
             author=get_current_user(),
+            emitter_data=emitter_data,
         )
     except Exception as e:
         logger.error(f"Simulation setup {setup_id} failed with error: {e}")

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/backtester/utils.py

@@ -213,38 +213,81 @@ class SignalsProxy(IStrategy):
         return None
 
 
+def _process_single_symbol_or_instrument(
+    symbol_or_instrument: SymbolOrInstrument_t,
+    default_exchange: ExchangeName_t | None,
+    requested_exchange: ExchangeName_t | None,
+) -> tuple[Instrument | None, str | None]:
+    """
+    Process a single symbol or instrument and return the resolved instrument and exchange.
+
+    Returns:
+        tuple[Instrument | None, str | None]: (instrument, exchange) or (None, None) if processing failed
+    """
+    match symbol_or_instrument:
+        case str():
+            _e, _s = (
+                symbol_or_instrument.split(":")
+                if ":" in symbol_or_instrument
+                else (default_exchange, symbol_or_instrument)
+            )
+
+            if _e is None:
+                logger.warning(
+                    f"Can't extract exchange name from symbol's spec ({symbol_or_instrument}) and exact exchange name is not provided - skip this symbol !"
+                )
+                return None, None
+
+            if (
+                requested_exchange is not None
+                and isinstance(requested_exchange, str)
+                and _e.lower() != requested_exchange.lower()
+            ):
+                logger.warning(
+                    f"Exchange from symbol's spec ({_e}) is different from requested: {requested_exchange} !"
+                )
+
+            if (instrument := lookup.find_symbol(_e, _s)) is not None:
+                return instrument, _e.upper()
+            else:
+                logger.warning(f"Can't find instrument for specified symbol ({symbol_or_instrument}) - ignoring !")
+                return None, None
+
+        case Instrument():
+            return symbol_or_instrument, symbol_or_instrument.exchange
+
+        case _:
+            raise SimulationConfigError(
+                f"Unsupported type for {symbol_or_instrument} only str or Instrument instances are allowed!"
+            )
+
+
 def find_instruments_and_exchanges(
     instruments: list[SymbolOrInstrument_t] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
-    exchange: ExchangeName_t | None,
+    exchange: ExchangeName_t | list[ExchangeName_t] | None,
 ) -> tuple[list[Instrument], list[ExchangeName_t]]:
     _instrs: list[Instrument] = []
-    _exchanges = [] if exchange is None else [exchange]
-    for i in instruments:
-        match i:
-            case str():
-                _e, _s = i.split(":") if ":" in i else (exchange, i)
-                assert _e is not None
+    _exchanges = [] if exchange is None else [exchange] if isinstance(exchange, str) else exchange
 
-                if exchange is not None and _e.lower() != exchange.lower():
-                    logger.warning("Exchange from symbol's spec ({_e}) is different from requested: {exchange} !")
+    # Handle dictionary case where instruments is {exchange: [symbols]}
+    if isinstance(instruments, dict):
+        for exchange_name, symbol_list in instruments.items():
+            if exchange_name not in _exchanges:
+                _exchanges.append(exchange_name)
 
-                if _e is None:
-                    logger.warning(
-                        "Can't extract exchange name from symbol's spec ({_e}) and exact exchange name is not provided - skip this symbol !"
-                    )
-
-                if (ix := lookup.find_symbol(_e, _s)) is not None:
-                    _exchanges.append(_e.upper())
-                    _instrs.append(ix)
-                else:
-                    logger.warning(f"Can't find instrument for specified symbol ({i}) - ignoring !")
+            for symbol in symbol_list:
+                instrument, resolved_exchange = _process_single_symbol_or_instrument(symbol, exchange_name, exchange)
+                if instrument is not None and resolved_exchange is not None:
+                    _instrs.append(instrument)
+                    _exchanges.append(resolved_exchange)
 
-            case Instrument():
-                _exchanges.append(i.exchange)
-                _instrs.append(i)
-
-            case _:
-                raise SimulationConfigError(f"Unsupported type for {i} only str or Instrument instances are allowed!")
+    # Handle list case
+    else:
+        for symbol in instruments:
+            instrument, resolved_exchange = _process_single_symbol_or_instrument(symbol, exchange, exchange)
+            if instrument is not None and resolved_exchange is not None:
+                _instrs.append(instrument)
+                _exchanges.append(resolved_exchange)
 
     return _instrs, list(set(_exchanges))
 

{qubx-0.6.62 → qubx-0.6.64}/src/qubx/core/account.py

@@ -7,6 +7,7 @@ from qubx.core.basics import (
     ZERO_COSTS,
     AssetBalance,
     Deal,
+    FundingPayment,
     Instrument,
     ITimeProvider,
     Order,
@@ -104,18 +105,23 @@ class BasicAccountProcessor(IAccountProcessor):
     ########################################################
     def get_leverage(self, instrument: Instrument) -> float:
         pos = self._positions.get(instrument)
+        capital = self.get_total_capital()
+        if np.isclose(capital, 0):
+            return 0.0
         if pos is not None:
-            return pos.notional_value / self.get_total_capital()
+            return pos.notional_value / capital
         return 0.0
 
     def get_leverages(self, exchange: str | None = None) -> dict[Instrument, float]:
         return {s: self.get_leverage(s) for s in self._positions.keys()}
 
     def get_net_leverage(self, exchange: str | None = None) -> float:
-        return sum(self.get_leverages(exchange).values())
+        leverages = self.get_leverages(exchange).values()
+        return sum(lev for lev in leverages if lev is not None and not np.isnan(lev))
 
     def get_gross_leverage(self, exchange: str | None = None) -> float:
-        return sum(map(abs, self.get_leverages(exchange).values()))
+        leverages = self.get_leverages(exchange).values()
+        return sum(abs(lev) for lev in leverages if lev is not None and not np.isnan(lev))
 
     ########################################################
     # Margin information
@@ -232,6 +238,36 @@ class BasicAccountProcessor(IAccountProcessor):
                         self._balances[self.base_currency] -= fee_in_base
                         self._balances[instrument.settle] += realized_pnl
 
+    def process_funding_payment(self, instrument: Instrument, funding_payment: FundingPayment) -> None:
+        """Process funding payment for an instrument.
+
+        Args:
+            instrument: Instrument the funding payment applies to
+            funding_payment: Funding payment event to process
+        """
+        pos = self._positions.get(instrument)
+
+        if pos is None or not instrument.is_futures():
+            return
+
+        # Get current market price for funding calculation
+        # We need to get the mark price from the market data, but since we don't have access
+        # to market data here, we'll use the current position price as a reasonable fallback
+        mark_price = pos.position_avg_price_funds if pos.position_avg_price_funds > 0 else 0.0
+
+        # Apply funding payment to position
+        funding_amount = pos.apply_funding_payment(funding_payment, mark_price)
+
+        # Update account balance with funding payment
+        # For futures contracts, funding affects the settlement currency balance
+        self._balances[instrument.settle] += funding_amount
+
+        logger.debug(
+            f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: "
+            f"funding payment {funding_amount:.6f} {instrument.settle} "
+            f"(rate: {funding_payment.funding_rate:.6f})"
+        )
+
     def _fill_missing_fee_info(self, instrument: Instrument, deals: list[Deal]) -> None:
         for d in deals:
             if d.fee_amount is None:
@@ -352,16 +388,48 @@ class CompositeAccountProcessor(IAccountProcessor):
         return self._account_processors[exch].get_capital()
 
     def get_total_capital(self, exchange: str | None = None) -> float:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_total_capital()
+        if exchange is not None:
+            # Return total capital from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_total_capital()
+
+        # Return aggregated total capital from all exchanges when no exchange is specified
+        total_capital = 0.0
+        for exch_name, processor in self._account_processors.items():
+            total_capital += processor.get_total_capital()
+        return total_capital
 
     def get_balances(self, exchange: str | None = None) -> dict[str, AssetBalance]:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_balances()
+        if exchange is not None:
+            # Return balances from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_balances()
+
+        # Return aggregated balances from all exchanges when no exchange is specified
+        all_balances: dict[str, AssetBalance] = defaultdict(lambda: AssetBalance())
+        for exch_name, processor in self._account_processors.items():
+            exch_balances = processor.get_balances()
+            for currency, balance in exch_balances.items():
+                if currency not in all_balances:
+                    all_balances[currency] = AssetBalance(balance.free, balance.locked, balance.total)
+                else:
+                    all_balances[currency].free += balance.free
+                    all_balances[currency].locked += balance.locked
+                    all_balances[currency].total += balance.total
+        return dict(all_balances)
 
     def get_positions(self, exchange: str | None = None) -> dict[Instrument, Position]:
-        exch = self._get_exchange(exchange)
-        return self._account_processors[exch].get_positions()
+        if exchange is not None:
+            # Return positions from specific exchange
+            exch = self._get_exchange(exchange)
+            return self._account_processors[exch].get_positions()
+
+        # Return positions from all exchanges when no exchange is specified
+        all_positions: dict[Instrument, Position] = {}
+        for exch_name, processor in self._account_processors.items():
+            exch_positions = processor.get_positions()
+            all_positions.update(exch_positions)
+        return all_positions
 
     def get_position(self, instrument: Instrument) -> Position:
         exch = self._get_exchange(instrument=instrument)
@@ -453,3 +521,7 @@ class CompositeAccountProcessor(IAccountProcessor):
     def process_deals(self, instrument: Instrument, deals: list[Deal]) -> None:
         exch = self._get_exchange(instrument=instrument)
         self._account_processors[exch].process_deals(instrument, deals)
+
+    def process_funding_payment(self, instrument: Instrument, funding_payment: FundingPayment) -> None:
+        exch = self._get_exchange(instrument=instrument)
+        self._account_processors[exch].process_funding_payment(instrument, funding_payment)