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

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/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/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/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/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/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/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/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/connectors/ccxt/handlers/trade.py

@@ -27,6 +27,40 @@ class TradeDataHandler(BaseDataTypeHandler):
     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:
@@ -42,6 +76,21 @@ class TradeDataHandler(BaseDataTypeHandler):
         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}
 
@@ -52,31 +101,13 @@ class TradeDataHandler(BaseDataTypeHandler):
             exch_symbol = trades[0]["symbol"]
             instrument = ccxt_find_instrument(exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument)
 
-            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))
-
-            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)
+            # 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 subscription configuration instead of calling _listen_to_stream directly
         return SubscriptionConfiguration(
             subscription_type=sub_type,
             subscriber_func=create_market_type_batched_subscriber(watch_trades, instruments),
@@ -85,6 +116,71 @@ class TradeDataHandler(BaseDataTypeHandler):
             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.

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/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/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
 

qubx/core/metrics.py

@@ -175,7 +175,7 @@ def cagr(returns, periods=DAILY):
 
     cumrets = (returns + 1).cumprod(axis=0)
     years = len(cumrets) / float(periods)
-    return (cumrets.iloc[-1] ** (1.0 / years)) - 1.0
+    return ((cumrets.iloc[-1] ** (1.0 / years)) - 1.0) * 100
 
 
 def calmar_ratio(returns, periods=DAILY):
@@ -747,6 +747,11 @@ class TradingSessionResult:
         """Get number of executions"""
         return len(self.executions_log)
 
+    @property
+    def turnover(self) -> float:
+        """Get average daily turnover as percentage of equity"""
+        return self.performance().get("avg_daily_turnover", 0.0)
+
     @property
     def leverage(self) -> pd.Series:
         """Get leverage over time"""
@@ -779,7 +784,7 @@ class TradingSessionResult:
             for k in [
                 "equity", "drawdown_usd", "drawdown_pct",
                 "compound_returns", "returns_daily", "returns", "monthly_returns",
-                "rolling_sharpe", "long_value", "short_value",
+                "rolling_sharpe", "long_value", "short_value", "turnover",
             ]:
                 self._metrics.pop(k, None)
             # fmt: on
@@ -1381,16 +1386,21 @@ def portfolio_metrics(
     execs = len(executions_log)
     mdd_pct = 100 * dd_data / equity.cummax() if execs > 0 else pd.Series(0, index=equity.index)
     sheet["equity"] = equity
-    sheet["gain"] = sheet["equity"].iloc[-1] - sheet["equity"].iloc[0]
-    sheet["cagr"] = cagr(returns_daily, performance_statistics_period)
     sheet["sharpe"] = sharpe_ratio(returns_daily, risk_free, performance_statistics_period)
+    sheet["cagr"] = cagr(returns_daily, performance_statistics_period)
+
+    # turnover calculation
+    symbols = list(set(portfolio_log.columns.str.split("_").str.get(0).values))
+    turnover_series = calculate_turnover(portfolio_log, symbols, equity, resample="1d")
+    sheet["turnover"] = turnover_series
+    sheet["daily_turnover"] = turnover_series.mean() if len(turnover_series) > 0 else 0.0
+
     sheet["qr"] = qr(equity) if execs > 0 else 0
-    sheet["drawdown_usd"] = dd_data
+    sheet["mdd_pct"] = max(mdd_pct)
     sheet["drawdown_pct"] = mdd_pct
+    sheet["drawdown_usd"] = dd_data
     # 25-May-2019: MDE fixed Max DD pct calculations
-    sheet["max_dd_pct"] = max(mdd_pct)
     # sheet["max_dd_pct_on_init"] = 100 * mdd / init_cash
-    sheet["mdd_usd"] = mdd
     sheet["mdd_start"] = equity.index[ddstart]
     sheet["mdd_peak"] = equity.index[ddpeak]
     sheet["mdd_recover"] = equity.index[ddrecover]
@@ -1403,12 +1413,12 @@ def portfolio_metrics(
     )
     sheet["calmar"] = calmar_ratio(returns_daily, performance_statistics_period)
     # sheet["ann_vol"] = annual_volatility(returns_daily)
-    sheet["tail_ratio"] = tail_ratio(returns_daily)
-    sheet["stability"] = stability_of_returns(returns_daily)
+    # sheet["tail_ratio"] = tail_ratio(returns_daily)
+    # sheet["stability"] = stability_of_returns(returns_daily)
     sheet["monthly_returns"] = aggregate_returns(returns_daily, convert_to="mon")
     r_m = np.mean(returns_daily)
     r_s = np.std(returns_daily)
-    sheet["var"] = var_cov_var(init_cash, r_m, r_s)
+    # sheet["var"] = var_cov_var(init_cash, r_m, r_s)
     sheet["avg_return"] = 100 * r_m
 
     # portfolio market values
@@ -1416,6 +1426,8 @@ def portfolio_metrics(
     sheet["long_value"] = mkt_value[mkt_value > 0].sum(axis=1).fillna(0)
     sheet["short_value"] = mkt_value[mkt_value < 0].sum(axis=1).fillna(0)
 
+    sheet["gain"] = sheet["equity"].iloc[-1] - sheet["equity"].iloc[0]
+    sheet["mdd_usd"] = mdd
     # total commissions
     sheet["fees"] = pft_total["Total_Commissions"].iloc[-1]
 
@@ -1423,9 +1435,10 @@ def portfolio_metrics(
     funding_columns = pft_total.filter(regex=".*_Funding")
     if not funding_columns.empty:
         total_funding = funding_columns.sum(axis=1)
-        sheet["funding_pnl"] = 100 * total_funding.iloc[-1] / init_cash  # as percentage of initial capital
-    else:
-        sheet["funding_pnl"] = 0.0
+        if total_funding.iloc[-1] != 0:
+            sheet["funding_pnl"] = 100 * total_funding.iloc[-1] / init_cash  # as percentage of initial capital
+    # else:
+    #     sheet["funding_pnl"] = 0.0
 
     # executions metrics
     sheet["execs"] = execs
@@ -1725,7 +1738,7 @@ def _tearsheet_single(
             ay = sbp(_n, 5)
             plt.plot(lev, c="c", lw=1.5, label="Leverage")
         plt.subplots_adjust(hspace=0)
-        return pd.DataFrame(report).T.round(3)
+        return pd.DataFrame(report).T.round(2)
 
 
 def calculate_leverage(
@@ -1828,6 +1841,53 @@ def calculate_pnl_per_symbol(
     return df
 
 
+def calculate_turnover(
+    portfolio_log: pd.DataFrame,
+    symbols: list[str],
+    equity: pd.Series,
+    resample: str = "1d",
+) -> pd.Series:
+    """
+    Calculate daily turnover as percentage of equity.
+
+    Turnover measures trading activity by calculating the absolute value of position changes
+    multiplied by price, then dividing by equity.
+
+    Args:
+        portfolio_log: Portfolio log dataframe with position and price columns
+        symbols: List of symbols to calculate turnover for
+        equity: Equity curve series
+        resample: Resampling period for turnover calculation (default "1d")
+
+    Returns:
+        pd.Series: Daily turnover as percentage of equity
+    """
+    position_diffs = []
+
+    for symbol in symbols:
+        pos_col = f"{symbol}_Pos"
+        price_col = f"{symbol}_Price"
+
+        if pos_col in portfolio_log.columns and price_col in portfolio_log.columns:
+            # Calculate absolute position change multiplied by price (notional value)
+            position_diff = portfolio_log[pos_col].diff().abs() * portfolio_log[price_col]
+            position_diffs.append(position_diff)
+
+    if not position_diffs:
+        return pd.Series(0, index=equity.index)
+
+    # Sum all position changes and resample to specified period
+    notional_turnover = pd.concat(position_diffs, axis=1).sum(axis=1).resample(resample).sum()
+
+    # Resample equity to match turnover frequency
+    equity_resampled = equity.resample(resample).last()
+
+    # Calculate turnover as percentage of equity
+    daily_turnover = notional_turnover.div(equity_resampled).mul(100).fillna(0)
+
+    return daily_turnover
+
+
 def chart_signals(
     result: TradingSessionResult,
     symbol: str,