quantex 0.4.8__tar.gz → 0.5.0__tar.gz

{quantex-0.4.8 → quantex-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: quantex
-Version: 0.4.8
+Version: 0.5.0
 Summary: A simple quant strategy creation and backtesting package.
 License: MIT
 Author: Daniel Green

{quantex-0.4.8 → quantex-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quantex"
-version = "0.4.8"
+version = "0.5.0"
 description = "A simple quant strategy creation and backtesting package."
 authors = [
     {name = "Daniel Green",email = "dangreen07@outlook.com"}

{quantex-0.4.8 → quantex-0.5.0}/src/quantex/backtester/__init__.py

@@ -18,6 +18,14 @@ from .parallel import _worker_init, _worker_eval
 # Monte Carlo simulation
 from .montecarlo import MonteCarloResult, MonteCarloMode
 
+# Walk-forward optimization
+from .walk_forward import (
+    WalkForwardResult,
+    WalkForwardWindow,
+    WalkForwardAnalyzer,
+    walk_forward_analyze,
+)
+
 __all__ = [
     # Constants
     "DataSplitMode",
@@ -42,4 +50,9 @@ __all__ = [
     # Monte Carlo
     "MonteCarloResult",
     "MonteCarloMode",
+    # Walk-forward optimization
+    "WalkForwardResult",
+    "WalkForwardWindow",
+    "WalkForwardAnalyzer",
+    "walk_forward_analyze",
 ]

{quantex-0.4.8 → quantex-0.5.0}/src/quantex/backtester/backtester.py

@@ -604,6 +604,7 @@ class SimpleBacktester:
         random_seed: int | None = None,
         workers: int | None = None,
         progress_bar: bool = True,
+        verbose: bool = False,
     ) -> OptimizationResult:
         """
         Optimize strategy parameters using Optuna (Bayesian optimization).
@@ -639,6 +640,8 @@ class SimpleBacktester:
             workers (int | None, optional): Number of parallel workers for Optuna
                 study. Defaults to None (sequential).
             progress_bar (bool, optional): Whether to show progress bar. Defaults to True.
+            verbose (bool, optional): Whether to show Optuna trial logs. Defaults to False
+                (suppresses verbose output).
             
         Returns:
             OptimizationResult: Object containing:
@@ -672,6 +675,10 @@ class SimpleBacktester:
         """
         try:
             import optuna
+            # Control optuna verbosity - logs every trial by default
+            optuna.logging.set_verbosity(
+                optuna.logging.INFO if verbose else optuna.logging.WARNING
+            )
         except ImportError:
             raise ImportError(
                 "optuna is required for optimize_optuna. "

{quantex-0.4.8 → quantex-0.5.0}/src/quantex/backtester/metrics.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import pandas as pd
 import numpy as np
+from datetime import timedelta
+from statistics import median
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -31,43 +33,37 @@ def max_drawdown(equity: pd.Series) -> float:
     max_dd = drawdown.min()
     return float(abs(max_dd))  # return as positive percentage
 
-
-def _infer_periods_per_year(index: pd.Index, default: int = 252 * 24 * 60) -> int:
+def _infer_periods_per_year(
+    index: pd.Index,
+    default: int = 252 * 24 * 60,
+) -> int:
     """
     Infer the number of trading periods per year from a datetime index.
-    
-    This function analyzes the time differences in the index to determine
-    the appropriate number of periods per year for annualized calculations.
+
     Falls back to minute-level trading (252 trading days * 24 hours * 60 minutes)
     if the index cannot be analyzed or contains insufficient data.
-    
-    Args:
-        index (pd.Index): DatetimeIndex containing timestamps.
-        default (int, optional): Default periods per year for minute trading.
-            Defaults to 252 * 24 * 60 (minute-level data).
-            
-    Returns:
-        int: Estimated number of trading periods per year.
-        
-    Example:
-        >>> dates = pd.date_range('2020-01-01', periods=100, freq='D')  
-        >>> _infer_periods_per_year(dates)  
-        252  # Daily trading periods
     """
-    # Simple inference; falls back to minute trading year if uncertain
     if not isinstance(index, pd.DatetimeIndex) or len(index) < 3:
         return default
-    dt = np.diff(index.values).astype("timedelta64[s]").astype(float)
-    if not np.isfinite(dt).any():
+
+    times = index.to_pydatetime()
+
+    deltas = []
+    for prev, curr in zip(times[:-1], times[1:]):
+        delta = curr - prev
+        if isinstance(delta, timedelta) and delta.total_seconds() > 0:
+            deltas.append(delta.total_seconds())
+
+    if not deltas:
         return default
-    med_sec = np.median(dt[dt > 0])
-    if not np.isfinite(med_sec) or med_sec <= 0:
+
+    med_sec = median(deltas)
+    if med_sec <= 0:
         return default
+
     periods_per_day = 86400.0 / med_sec
-    # Assume 252 trading days/year
     return int(round(252 * periods_per_day))
 
-
 def _compute_backtest_metrics(report: BacktestReport) -> dict[str, Any]:
     """Compute performance metrics from a BacktestReport."""
     equity = report.PnlRecord.astype(float)
@@ -76,7 +72,12 @@ def _compute_backtest_metrics(report: BacktestReport) -> dict[str, Any]:
     annual_rf = report.annual_rf
     rf_per_period = annual_rf / report.periods_per_year
 
-    if len(returns) < 2 or returns.std(ddof=1) == 0:
+    # If margin calls occurred, the backtest is invalid - position was forcibly closed
+    # This means the strategy was using too much leverage and the Sharpe is meaningless
+    margin_calls = len(report.margin_call_events or [])
+    if margin_calls > 0:
+        sharpe = float("nan")
+    elif len(returns) < 2 or returns.std(ddof=1) == 0:
         sharpe = float("nan")
     else:
         excess = returns - rf_per_period

{quantex-0.4.8 → quantex-0.5.0}/src/quantex/backtester/reports.py

@@ -178,7 +178,14 @@ class BacktestReport:
         # Risk-free per period from an annual rate
         rf_per_period = self.annual_rf / self.periods_per_year
 
-        if len(returns) < 2 or returns.std(ddof=1) == 0:
+        # If margin calls occurred, the backtest is invalid - position was forcibly closed
+        # This means the strategy was using too much leverage and the Sharpe is meaningless
+        margin_calls = len(self.margin_call_events or [])
+        if margin_calls > 0:
+            sharpe = np.nan
+            lo = np.nan
+            hi = np.nan
+        elif len(returns) < 2 or returns.std(ddof=1) == 0:
             sharpe = np.nan
             lo = np.nan
             hi = np.nan
@@ -203,7 +210,6 @@ class BacktestReport:
         tot_return = float(equity.iloc[-1] / equity.iloc[0] - 1.0)
         annualized_return = float((1.0 + tot_return) ** (self.periods_per_year / max(len(returns), 1)) - 1.0)
         tot_orders = len(self.orders)
-        margin_calls = len(self.margin_call_events or [])
 
         return (
             f"Starting Cash: ${self.starting_cash:,.2f}\n"