Qubx 0.6.84__tar.gz → 0.6.87__tar.gz

{qubx-0.6.84 → qubx-0.6.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.84
+Version: 0.6.87
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.6.84 → qubx-0.6.87}/pyproject.toml

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

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/backtester/management.py

@@ -327,10 +327,11 @@ class BacktestsResultsManager:
                 if not as_table:
                     print(_s)
 
+                dd_column = "max_dd_pct" if "max_dd_pct" in metrics else "mdd_pct"
                 if with_metrics:
                     _m_repr = (
                         pd.DataFrame.from_dict(metrics, orient="index")
-                        .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                        .T[["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]]
                         .astype(float)
                     )
                     _m_repr = _m_repr.round(3).to_string(index=False)
@@ -345,7 +346,7 @@ class BacktestsResultsManager:
                     metrics = {
                         m: round(v, 3)
                         for m, v in metrics.items()
-                        if m in ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                        if m in ["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]
                     }
                     _t_rep.append(
                         {"Index": info.get("idx", ""), "Strategy": name}

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/backtester/runner.py

@@ -478,7 +478,7 @@ class SimulationRunner:
         )
 
         if self.emitter is not None:
-            self.emitter.set_time_provider(simulated_clock)
+            self.emitter.set_context(ctx)
 
         # - setup base subscription from spec
         if ctx.get_base_subscription() == DataType.NONE:

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/cli/commands.py

@@ -137,6 +137,51 @@ def ls(directory: str):
     ls_strats(directory)
 
 
+@main.command()
+@click.argument("config-file", type=Path, required=True)
+@click.option(
+    "--no-check-imports",
+    is_flag=True,
+    default=False,
+    help="Skip checking if strategy class can be imported",
+    show_default=True,
+)
+def validate(config_file: Path, no_check_imports: bool):
+    """
+    Validates a strategy configuration file without running it.
+
+    Checks for:
+    - Valid YAML syntax
+    - Required configuration fields
+    - Strategy class exists and can be imported (unless --no-check-imports)
+    - Exchange configurations are valid
+    - Simulation parameters are valid (if present)
+
+    Returns exit code 0 if valid, 1 if invalid.
+    """
+    from qubx.utils.runner.configs import validate_strategy_config
+
+    result = validate_strategy_config(config_file, check_imports=not no_check_imports)
+
+    if result.valid:
+        click.echo(click.style("✓ Configuration is valid", fg="green", bold=True))
+        if result.warnings:
+            click.echo(click.style("\nWarnings:", fg="yellow", bold=True))
+            for warning in result.warnings:
+                click.echo(click.style(f"  - {warning}", fg="yellow"))
+        raise SystemExit(0)
+    else:
+        click.echo(click.style("✗ Configuration is invalid", fg="red", bold=True))
+        click.echo(click.style("\nErrors:", fg="red", bold=True))
+        for error in result.errors:
+            click.echo(click.style(f"  - {error}", fg="red"))
+        if result.warnings:
+            click.echo(click.style("\nWarnings:", fg="yellow", bold=True))
+            for warning in result.warnings:
+                click.echo(click.style(f"  - {warning}", fg="yellow"))
+        raise SystemExit(1)
+
+
 @main.command()
 @click.argument(
     "directory",
@@ -358,7 +403,7 @@ def init(
     The generated strategy can be run immediately with:
     poetry run qubx run --config config.yml --paper
     """
-    from qubx.templates import TemplateManager, TemplateError
+    from qubx.templates import TemplateError, TemplateManager
     
     try:
         manager = TemplateManager()

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/account.py

@@ -130,6 +130,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
         if not self.exchange_manager.exchange.isSandboxModeEnabled:
             # - start polling tasks
+            self._loop.submit(self.exchange_manager.exchange.load_markets()).result()
             self._polling_tasks["balance"] = self._loop.submit(
                 self._poller("balance", self._update_balance, self.balance_interval)
             )

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/exchanges/hyperliquid/broker.py

@@ -9,7 +9,7 @@ from qubx.core.exceptions import BadRequest
 class HyperliquidCcxtBroker(CcxtBroker):
     """
     HyperLiquid-specific broker that handles market order slippage requirements.
-    
+
     HyperLiquid requires a price even for market orders to calculate max slippage.
     This broker automatically calculates slippage-protected prices for market orders.
     """
@@ -17,7 +17,7 @@ class HyperliquidCcxtBroker(CcxtBroker):
     def __init__(
         self,
         *args,
-        market_order_slippage: float = 0.05,  # 5% default slippage
+        market_order_slippage: float = 0.01,  # 5% default slippage
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -38,21 +38,29 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if order_type.lower() == "market" and price is None:
             quote = self.data_provider.get_quote(instrument)
             if quote is None:
-                logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation.")
-                raise BadRequest(f"Quote is not available for market order slippage calculation for {instrument.symbol}")
+                logger.warning(
+                    f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation."
+                )
+                raise BadRequest(
+                    f"Quote is not available for market order slippage calculation for {instrument.symbol}"
+                )
 
             # Get slippage from options or use default
             slippage = options.get("slippage", self.market_order_slippage)
-            
+
             # Calculate slippage-protected price
             if order_side.upper() == "BUY":
                 # For buy orders, add slippage to ask price to ensure execution
                 price = quote.ask * (1 + slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})"
+                )
             else:  # SELL
                 # For sell orders, subtract slippage from bid price to ensure execution
                 price = quote.bid * (1 - slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})"
+                )
 
         # Call parent implementation with calculated price
         payload = super()._prepare_order_payload(
@@ -64,6 +72,6 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if "slippage" in options:
             # HyperLiquid accepts slippage as a percentage (e.g., 0.05 for 5%)
             params["px"] = price  # Explicit price for slippage calculation
-            
+
         payload["params"] = params
-        return payload
+        return payload

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/exchanges/hyperliquid/hyperliquid.py

@@ -8,7 +8,7 @@ from ...adapters.polling_adapter import PollingConfig, PollingToWebSocketAdapter
 from ..base import CcxtFuturePatchMixin
 
 # Constants
-FUNDING_RATE_DEFAULT_POLL_MINUTES = 5
+FUNDING_RATE_DEFAULT_POLL_MINUTES = 1
 FUNDING_RATE_HOUR_MS = 60 * 60 * 1000  # 1 hour in milliseconds
 
 

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/handlers/funding_rate.py

@@ -71,7 +71,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
                             channel.send((instrument, DataType.FUNDING_RATE, funding_rate, False))
 
                             # Emit payment if funding interval changed
-                            if self._should_emit_payment(instrument, funding_rate):
+                            if self._should_emit_payment(instrument, funding_rate, current_time):
                                 payment = self._create_funding_payment(instrument)
                                 channel.send((instrument, DataType.FUNDING_PAYMENT, payment, False))
 
@@ -101,7 +101,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
             stream_name=name,
         )
 
-    def _should_emit_payment(self, instrument: Instrument, rate: FundingRate) -> bool:
+    def _should_emit_payment(self, instrument: Instrument, rate: FundingRate, current_time: dt_64) -> bool:
         """
         Determine if a funding payment should be emitted.
 
@@ -132,7 +132,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
             return False
 
         # Emit if next_funding_time has advanced (new funding period started)
-        if rate.next_funding_time > last_info["payment_time"]:
+        if rate.next_funding_time > last_info["payment_time"] and current_time > last_info["payment_time"]:
             # Store payment info for _create_funding_payment
             self._pending_funding_rates[f"{key}_payment"] = {
                 "rate": last_info["rate"].rate,

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/handlers/orderbook.py

@@ -65,7 +65,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
 
         # Notify all listeners
         self._data_provider.notify_data_arrival(sub_type, dt_64(ob.time, "ns"))
-        
+
         channel.send((instrument, sub_type, ob, False))
         return True
 
@@ -150,7 +150,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
     ) -> SubscriptionConfiguration:
         """
         Prepare subscription configuration for individual instruments.
-        
+
         Creates separate subscriber functions for each instrument to enable independent
         WebSocket streams without waiting for all instruments. This follows the same
         pattern as the OHLC handler for proper individual stream management.
@@ -169,10 +169,10 @@ class OrderBookDataHandler(BaseDataTypeHandler):
                     try:
                         # Watch orderbook for single instrument
                         ccxt_ob = await self._exchange_manager.exchange.watch_order_book(symbol)
-                        
+
                         # Use private processing method to avoid duplication
                         self._process_orderbook(ccxt_ob, inst, sub_type, channel, depth, tick_size_pct)
-                        
+
                     except Exception as e:
                         logger.error(
                             f"<yellow>{exchange_id}</yellow> Error in individual orderbook subscription for {inst.symbol}: {e}"
@@ -186,13 +186,15 @@ class OrderBookDataHandler(BaseDataTypeHandler):
             # Create individual unsubscriber if exchange supports it
             un_watch_method = getattr(self._exchange_manager.exchange, "un_watch_order_book", None)
             if un_watch_method is not None and callable(un_watch_method):
-                
+
                 def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
                     async def individual_unsubscriber():
                         try:
                             await self._exchange_manager.exchange.un_watch_order_book(symbol)
                         except Exception as e:
-                            logger.error(f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}")
+                            logger.error(
+                                f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}"
+                            )
 
                     return individual_unsubscriber
 

qubx-0.6.87/src/qubx/connectors/ccxt/handlers/trade.py

@@ -0,0 +1,207 @@
+"""
+Trade data type handler for CCXT data provider.
+
+Handles subscription and warmup for trade data.
+"""
+
+from typing import Set
+
+from qubx import logger
+from qubx.core.basics import CtrlChannel, DataType, Instrument, dt_64
+from qubx.core.series import Quote
+
+from ..subscription_config import SubscriptionConfiguration
+from ..utils import (
+    ccxt_convert_trade,
+    ccxt_find_instrument,
+    create_market_type_batched_subscriber,
+    instrument_to_ccxt_symbol,
+)
+from .base import BaseDataTypeHandler
+
+
+class TradeDataHandler(BaseDataTypeHandler):
+    """Handler for trade data subscription and processing."""
+
+    @property
+    def data_type(self) -> str:
+        return "trade"
+
+    def _process_trade(self, trades: list, instrument: Instrument, sub_type: str, channel: CtrlChannel):
+        """
+        Process trades with synthetic quote generation.
+
+        This method handles the common logic for processing trade data that's shared between
+        bulk and individual subscription approaches.
+
+        Args:
+            trades: List of CCXT trade dictionaries
+            instrument: Instrument these trades belong to
+            sub_type: Subscription type string
+            channel: Control channel to send data through
+        """
+        for trade in trades:
+            converted_trade = ccxt_convert_trade(trade)
+
+            # Notify all listeners
+            self._data_provider.notify_data_arrival(sub_type, dt_64(converted_trade.time, "ns"))
+
+            channel.send((instrument, sub_type, converted_trade, False))
+
+        # Generate synthetic quote if no quote/orderbook subscription exists
+        if len(trades) > 0 and not (
+            self._data_provider.has_subscription(instrument, DataType.ORDERBOOK)
+            or self._data_provider.has_subscription(instrument, DataType.QUOTE)
+        ):
+            last_trade = trades[-1]
+            converted_trade = ccxt_convert_trade(last_trade)
+            _price = converted_trade.price
+            _time = converted_trade.time
+            _s2 = instrument.tick_size / 2.0
+            _bid, _ask = _price - _s2, _price + _s2
+            self._data_provider._last_quotes[instrument] = Quote(_time, _bid, _ask, 0.0, 0.0)
+
+    def prepare_subscription(
+        self, name: str, sub_type: str, channel: CtrlChannel, instruments: Set[Instrument], **params
+    ) -> SubscriptionConfiguration:
+        """
+        Prepare trade subscription configuration.
+
+        Args:
+            name: Stream name for this subscription
+            sub_type: Parsed subscription type ("trade")
+            channel: Control channel for managing subscription lifecycle
+            instruments: Set of instruments to subscribe to
+
+        Returns:
+            SubscriptionConfiguration with subscriber and unsubscriber functions
+        """
+        # Use exchange-specific approach based on capabilities
+        if self._exchange_manager.exchange.has.get("watchTradesForSymbols", False):
+            return self._prepare_subscription_for_instruments(name, sub_type, channel, instruments)
+        else:
+            # Fall back to individual instrument subscriptions
+            return self._prepare_subscription_for_individual_instruments(name, sub_type, channel, instruments)
+
+    def _prepare_subscription_for_instruments(
+        self,
+        name: str,
+        sub_type: str,
+        channel: CtrlChannel,
+        instruments: Set[Instrument],
+    ) -> SubscriptionConfiguration:
+        """Prepare subscription configuration for multiple instruments using bulk API."""
+        _instr_to_ccxt_symbol = {i: instrument_to_ccxt_symbol(i) for i in instruments}
+        _symbol_to_instrument = {_instr_to_ccxt_symbol[i]: i for i in instruments}
+
+        async def watch_trades(instruments_batch: list[Instrument]):
+            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
+            trades = await self._exchange_manager.exchange.watch_trades_for_symbols(symbols)
+
+            exch_symbol = trades[0]["symbol"]
+            instrument = ccxt_find_instrument(exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument)
+
+            # Use private processing method to avoid duplication
+            self._process_trade(trades, instrument, sub_type, channel)
+
+        async def un_watch_trades(instruments_batch: list[Instrument]):
+            symbols = [_instr_to_ccxt_symbol[i] for i in instruments_batch]
+            await self._exchange_manager.exchange.un_watch_trades_for_symbols(symbols)
+
+        return SubscriptionConfiguration(
+            subscription_type=sub_type,
+            subscriber_func=create_market_type_batched_subscriber(watch_trades, instruments),
+            unsubscriber_func=create_market_type_batched_subscriber(un_watch_trades, instruments),
+            stream_name=name,
+            requires_market_type_batching=True,
+        )
+
+    def _prepare_subscription_for_individual_instruments(
+        self,
+        name: str,
+        sub_type: str,
+        channel: CtrlChannel,
+        instruments: Set[Instrument],
+    ) -> SubscriptionConfiguration:
+        """
+        Prepare subscription configuration for individual instruments.
+
+        Creates separate subscriber functions for each instrument to enable independent
+        WebSocket streams without waiting for all instruments. This follows the same
+        pattern as the orderbook handler for proper individual stream management.
+        """
+        _instr_to_ccxt_symbol = {i: instrument_to_ccxt_symbol(i) for i in instruments}
+
+        individual_subscribers = {}
+        individual_unsubscribers = {}
+
+        for instrument in instruments:
+            ccxt_symbol = _instr_to_ccxt_symbol[instrument]
+
+            # Create individual subscriber for this instrument using closure
+            def create_individual_subscriber(inst=instrument, symbol=ccxt_symbol, exchange_id=self._exchange_id):
+                async def individual_subscriber():
+                    try:
+                        # Watch trades for single instrument
+                        trades = await self._exchange_manager.exchange.watch_trades(symbol)
+
+                        # Use private processing method to avoid duplication
+                        self._process_trade(trades, inst, sub_type, channel)
+
+                    except Exception as e:
+                        logger.error(
+                            f"<yellow>{exchange_id}</yellow> Error in individual trade subscription for {inst.symbol}: {e}"
+                        )
+                        raise  # Let connection manager handle retries
+
+                return individual_subscriber
+
+            individual_subscribers[instrument] = create_individual_subscriber()
+
+            # Create individual unsubscriber if exchange supports it
+            un_watch_method = getattr(self._exchange_manager.exchange, "un_watch_trades", None)
+            if un_watch_method is not None and callable(un_watch_method):
+
+                def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
+                    async def individual_unsubscriber():
+                        try:
+                            await self._exchange_manager.exchange.un_watch_trades(symbol)
+                        except Exception as e:
+                            logger.error(f"<yellow>{exchange_id}</yellow> Error unsubscribing trades for {symbol}: {e}")
+
+                    return individual_unsubscriber
+
+                individual_unsubscribers[instrument] = create_individual_unsubscriber()
+
+        return SubscriptionConfiguration(
+            subscription_type=sub_type,
+            instrument_subscribers=individual_subscribers,
+            instrument_unsubscribers=individual_unsubscribers if individual_unsubscribers else None,
+            stream_name=name,
+            requires_market_type_batching=False,
+        )
+
+    async def warmup(self, instruments: Set[Instrument], channel: CtrlChannel, warmup_period: str, **params) -> None:
+        """
+        Fetch historical trade data for warmup during backtesting.
+
+        Args:
+            instruments: Set of instruments to warm up
+            channel: Control channel for sending warmup data
+            warmup_period: Period to warm up (e.g., "30d", "1000h")
+        """
+        for instrument in instruments:
+            trades = await self._exchange_manager.exchange.fetch_trades(
+                instrument.symbol, since=self._data_provider._time_msec_nbars_back(warmup_period)
+            )
+
+            logger.debug(f"<yellow>{self._exchange_id}</yellow> Loaded {len(trades)} trades for {instrument}")
+
+            channel.send(
+                (
+                    instrument,
+                    DataType.TRADE,
+                    [ccxt_convert_trade(trade) for trade in trades],
+                    True,  # historical data
+                )
+            )

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/connectors/ccxt/reader.py

@@ -20,7 +20,7 @@ from .utils import ccxt_find_instrument, instrument_to_ccxt_symbol
 
 @reader("ccxt")
 class CcxtDataReader(DataReader):
-    SUPPORTED_DATA_TYPES = {"ohlc", "funding_payment"}
+    SUPPORTED_DATA_TYPES = {"ohlc"}
 
     _exchanges: dict[str, Exchange]
     _loop: AsyncThreadLoop
@@ -74,7 +74,8 @@ class CcxtDataReader(DataReader):
         if instrument is None:
             return []
 
-        _timeframe = pd.Timedelta(timeframe or "1m")
+        timeframe = timeframe or "1m"
+        _timeframe = pd.Timedelta(timeframe)
         _start, _stop = self._get_start_stop(start, stop, _timeframe)
 
         if _start > _stop:

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/core/helpers.py

@@ -233,10 +233,16 @@ class CachedMarketDataHolder:
         if series:
             total_vol = trade.size
             bought_vol = total_vol if trade.side == 1 else 0.0
+            volume_quote = trade.price * trade.size
+            bought_volume_quote = volume_quote if trade.side == 1 else 0.0
             for ser in series.values():
-                if len(ser) > 0 and ser[0].time > trade.time:
-                    continue
-                ser.update(trade.time, trade.price, total_vol, bought_vol)
+                if len(ser) > 0:
+                    current_bar_start = floor_t64(np.datetime64(ser[0].time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    trade_bar_start = floor_t64(np.datetime64(trade.time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    if trade_bar_start < current_bar_start:
+                        # Trade belongs to a previous bar - skip it
+                        continue
+                ser.update(trade.time, trade.price, total_vol, bought_vol, volume_quote, bought_volume_quote, 1)
 
     def finalize_ohlc_for_instruments(self, time: dt_64, instruments: list[Instrument]):
         """

{qubx-0.6.84 → qubx-0.6.87}/src/qubx/core/interfaces.py

@@ -2050,7 +2050,7 @@ class IMetricEmitter:
         self,
         name: str,
         value: float,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         timestamp: dt_64 | None = None,
         instrument: Instrument | None = None,
     ) -> None:
@@ -2092,15 +2092,16 @@ class IMetricEmitter:
         """
         pass
 
-    def set_time_provider(self, time_provider: ITimeProvider) -> None:
+    def set_context(self, context: "IStrategyContext") -> None:
         """
-        Set the time provider for the metric emitter.
+        Set the strategy context for the metric emitter.
 
-        This method is used to set the time provider that will be used to get timestamps
-        when no explicit timestamp is provided in the emit method.
+        This method is used to set the context that provides access to time and simulation state.
+        The context is used to automatically add is_live tag and get timestamps when no explicit
+        timestamp is provided in the emit method.
 
         Args:
-            time_provider: The time provider to use
+            context: The strategy context to use
         """
         pass