investing-algorithm-framework 8.5.0__tar.gz → 8.6.0__tar.gz

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 8.5.0
+Version: 8.6.0
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10,<4.0

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/investing_algorithm_framework/__init__.py

@@ -67,7 +67,9 @@ from .services import get_annual_volatility, get_sortino_ratio, \
     get_current_average_trade_loss, get_negative_trades, \
     get_positive_trades, get_number_of_trades, get_current_win_rate, \
     get_current_win_loss_ratio, create_backtest_metrics_for_backtest, \
-    recalculate_backtests, TradeTakeProfitService, TradeStopLossService
+    recalculate_backtests, TradeTakeProfitService, TradeStopLossService, \
+    get_cv_consistency, get_normalized_stability, \
+    get_consistency_score, get_stability_score
 
 
 __all__ = [
@@ -255,6 +257,10 @@ __all__ = [
     "FXRateProvider",
     "StaticFXRateProvider",
     "load_ipython_extension",
+    "get_cv_consistency",
+    "get_normalized_stability",
+    "get_consistency_score",
+    "get_stability_score",
 ]
 
 

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/investing_algorithm_framework/domain/backtesting/combine_backtests.py

@@ -2,6 +2,10 @@ import logging
 import math
 from typing import List
 
+from .consistency import (
+    get_cv_consistency, get_normalized_stability,
+    get_consistency_score, get_stability_score,
+)
 from .backtest_metrics import BacktestMetrics
 from .backtest_summary_metrics import BacktestSummaryMetrics
 
@@ -441,45 +445,14 @@ def generate_backtest_summary_metrics(
     ) if consecutive_losses else None
 
     # === CONSISTENCY METRICS ===
-    # Two complementary approaches to measure cross-window stability.
-    #
-    # 1) CV-based consistency: 1 - CV  (CV = std / |mean|), capped [0, 1].
-    #    Standard statistical measure; scale-invariant.
-    #    Drawback: undefined when mean ≈ 0.
-    #
-    # 2) Normalized-std stability: 1 - std/max_std, capped [0, 1].
-    #    Uses a domain-specific max_std for normalization.
-    #    More intuitive for bounded metrics (win rate 0-100,
-    #    Sharpe typically -2 to +4).
-
     return_consistency = None
     win_rate_consistency = None
     sharpe_consistency = None
-    consistency_score = None
+    consistency_score_val = None
     return_stability = None
     win_rate_stability = None
     sharpe_stability = None
-    stability_score = None
-
-    def _cv_consistency(values):
-        """1 - CV capped to [0, 1], or None if insufficient data."""
-        if len(values) < 2:
-            return None
-        mean = sum(values) / len(values)
-        if abs(mean) < 1e-9:
-            return 0.0  # mean ≈ 0 → unstable
-        var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
-        cv = math.sqrt(var) / abs(mean)
-        return max(0.0, min(1.0, 1.0 - cv))
-
-    def _norm_stability(values, max_std):
-        """1 - std/max_std capped to [0, 1], or None if insufficient."""
-        if len(values) < 2:
-            return None
-        mean = sum(values) / len(values)
-        var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
-        std = math.sqrt(var)
-        return max(0.0, min(1.0, 1.0 - std / max_std))
+    stability_score_val = None
 
     if len(valid_metrics) >= 2:
         # --- Per-window returns ---
@@ -487,9 +460,10 @@ def generate_backtest_summary_metrics(
             b.total_net_gain_percentage for b in valid_metrics
             if b.total_net_gain_percentage is not None
         ]
-        return_consistency = _cv_consistency(per_window_returns)
-        # max_std = 100: a std of 100% of initial capital → score 0
-        return_stability = _norm_stability(per_window_returns, 100.0)
+        return_consistency = get_cv_consistency(per_window_returns)
+        return_stability = get_normalized_stability(
+            per_window_returns, 100.0
+        )
 
         # --- Per-window win rates ---
         per_window_win_rates = [
@@ -498,10 +472,10 @@ def generate_backtest_summary_metrics(
             and b.number_of_trades_closed is not None
             and b.number_of_trades_closed > 0
         ]
-        return_consistency = _cv_consistency(per_window_returns)
-        win_rate_consistency = _cv_consistency(per_window_win_rates)
-        # max_std = 50: theoretical max std for a [0, 100] range
-        win_rate_stability = _norm_stability(per_window_win_rates, 50.0)
+        win_rate_consistency = get_cv_consistency(per_window_win_rates)
+        win_rate_stability = get_normalized_stability(
+            per_window_win_rates, 50.0
+        )
 
         # --- Per-window Sharpe ratios ---
         per_window_sharpe = [
@@ -510,45 +484,19 @@ def generate_backtest_summary_metrics(
             and not math.isnan(b.sharpe_ratio)
             and not math.isinf(b.sharpe_ratio)
         ]
-        sharpe_consistency = _cv_consistency(per_window_sharpe)
-        # max_std = 2: Sharpe ratios typically range -2 to +4;
-        # a std of 2 means wildly inconsistent
-        sharpe_stability = _norm_stability(per_window_sharpe, 2.0)
+        sharpe_consistency = get_cv_consistency(per_window_sharpe)
+        sharpe_stability = get_normalized_stability(
+            per_window_sharpe, 2.0
+        )
 
         # --- Composite scores ---
-        # Both use the same weighting scheme:
-        # 35% returns, 25% win rate, 20% Sharpe, 20% profitable
-        # window ratio.
-        def _composite(ret_c, wr_c, sh_c):
-            components = []
-            weights_c = []
-            if ret_c is not None:
-                components.append(ret_c)
-                weights_c.append(0.35)
-            if wr_c is not None:
-                components.append(wr_c)
-                weights_c.append(0.25)
-            if sh_c is not None:
-                components.append(sh_c)
-                weights_c.append(0.20)
-            if number_of_windows and number_of_windows > 0:
-                pw_ratio = (
-                    number_of_profitable_windows / number_of_windows
-                )
-                components.append(pw_ratio)
-                weights_c.append(0.20)
-            if not components:
-                return None
-            total_w = sum(weights_c)
-            return sum(
-                c * w for c, w in zip(components, weights_c)
-            ) / total_w
-
-        consistency_score = _composite(
-            return_consistency, win_rate_consistency, sharpe_consistency
+        consistency_score_val = get_consistency_score(
+            return_consistency, win_rate_consistency, sharpe_consistency,
+            number_of_profitable_windows, number_of_windows,
         )
-        stability_score = _composite(
-            return_stability, win_rate_stability, sharpe_stability
+        stability_score_val = get_stability_score(
+            return_stability, win_rate_stability, sharpe_stability,
+            number_of_profitable_windows, number_of_windows,
         )
 
     return BacktestSummaryMetrics(
@@ -602,9 +550,9 @@ def generate_backtest_summary_metrics(
         return_consistency=return_consistency,
         win_rate_consistency=win_rate_consistency,
         sharpe_consistency=sharpe_consistency,
-        consistency_score=consistency_score,
+        consistency_score=consistency_score_val,
         return_stability=return_stability,
         win_rate_stability=win_rate_stability,
         sharpe_stability=sharpe_stability,
-        stability_score=stability_score,
+        stability_score=stability_score_val,
     )

investing_algorithm_framework-8.6.0/investing_algorithm_framework/domain/backtesting/consistency.py

@@ -0,0 +1,137 @@
+import math
+
+
+def get_cv_consistency(values):
+    """
+    CV-based consistency: 1 - CV (CV = std / |mean|), capped [0, 1].
+
+    Standard statistical measure; scale-invariant.
+    Returns None if fewer than 2 values.
+    Returns 0.0 when mean ≈ 0 (unstable).
+
+    Args:
+        values: list of numeric values (e.g. per-window returns)
+
+    Returns:
+        float in [0, 1] or None
+    """
+    if len(values) < 2:
+        return None
+    mean = sum(values) / len(values)
+    if abs(mean) < 1e-9:
+        return 0.0
+    var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
+    cv = math.sqrt(var) / abs(mean)
+    return max(0.0, min(1.0, 1.0 - cv))
+
+
+def get_normalized_stability(values, max_std):
+    """
+    Normalized-std stability: 1 - std/max_std, capped [0, 1].
+
+    Uses a domain-specific max_std for normalization.
+    More intuitive for bounded metrics (win rate 0-100,
+    Sharpe typically -2 to +4).
+    Returns None if fewer than 2 values.
+
+    Args:
+        values: list of numeric values (e.g. per-window win rates)
+        max_std: domain-specific maximum standard deviation for
+                 normalization
+
+    Returns:
+        float in [0, 1] or None
+    """
+    if len(values) < 2:
+        return None
+    mean = sum(values) / len(values)
+    var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
+    std = math.sqrt(var)
+    return max(0.0, min(1.0, 1.0 - std / max_std))
+
+
+def get_consistency_score(
+    return_consistency,
+    win_rate_consistency,
+    sharpe_consistency,
+    number_of_profitable_windows=None,
+    number_of_windows=None,
+):
+    """
+    Composite consistency score using weighted components:
+    35% returns, 25% win rate, 20% Sharpe, 20% profitable window ratio.
+
+    Args:
+        return_consistency: CV consistency of per-window returns
+        win_rate_consistency: CV consistency of per-window win rates
+        sharpe_consistency: CV consistency of per-window Sharpe ratios
+        number_of_profitable_windows: count of profitable windows
+        number_of_windows: total number of windows
+
+    Returns:
+        float in [0, 1] or None
+    """
+    return _composite(
+        return_consistency,
+        win_rate_consistency,
+        sharpe_consistency,
+        number_of_profitable_windows,
+        number_of_windows,
+    )
+
+
+def get_stability_score(
+    return_stability,
+    win_rate_stability,
+    sharpe_stability,
+    number_of_profitable_windows=None,
+    number_of_windows=None,
+):
+    """
+    Composite stability score using weighted components:
+    35% returns, 25% win rate, 20% Sharpe, 20% profitable window ratio.
+
+    Args:
+        return_stability: normalized stability of per-window returns
+        win_rate_stability: normalized stability of per-window win rates
+        sharpe_stability: normalized stability of per-window Sharpe ratios
+        number_of_profitable_windows: count of profitable windows
+        number_of_windows: total number of windows
+
+    Returns:
+        float in [0, 1] or None
+    """
+    return _composite(
+        return_stability,
+        win_rate_stability,
+        sharpe_stability,
+        number_of_profitable_windows,
+        number_of_windows,
+    )
+
+
+def _composite(
+    ret_c, wr_c, sh_c,
+    number_of_profitable_windows=None,
+    number_of_windows=None,
+):
+    components = []
+    weights_c = []
+    if ret_c is not None:
+        components.append(ret_c)
+        weights_c.append(0.35)
+    if wr_c is not None:
+        components.append(wr_c)
+        weights_c.append(0.25)
+    if sh_c is not None:
+        components.append(sh_c)
+        weights_c.append(0.20)
+    if number_of_windows and number_of_windows > 0 \
+            and number_of_profitable_windows is not None:
+        pw_ratio = number_of_profitable_windows / number_of_windows
+        components.append(pw_ratio)
+        weights_c.append(0.20)
+    if not components:
+        return None
+    total_w = sum(weights_c)
+    return sum(c * w for c, w in zip(components, weights_c)) / total_w

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/investing_algorithm_framework/infrastructure/services/backtesting/backtest_service.py

@@ -31,20 +31,42 @@ from .vector_backtest_service import VectorBacktestService
 
 logger = logging.getLogger(__name__)
 
-# Module-level global used by worker processes. Set via _init_worker
+# Module-level globals used by worker processes. Set via _init_worker
 # which is called once per worker by ProcessPoolExecutor's initializer.
 _worker_data_provider_service = None
+_worker_progress_counter = None
 
 
-def _init_worker(data_provider_service):
+def _init_worker(data_provider_service, progress_counter=None):
     """Initializer for ProcessPoolExecutor workers.
 
-    Stores the data_provider_service in a module-level global so each
-    worker pickles/unpickles it only once at startup rather than per task.
-    This dramatically reduces overhead on Windows/WSL (spawn start method).
+    Stores the data_provider_service and a shared progress counter in
+    module-level globals so each worker inherits them once at startup
+    rather than pickling them per task. This dramatically reduces
+    overhead on Windows/WSL (spawn start method).
+
+    Also pins BLAS / OpenMP / Polars thread pools to a single thread per
+    worker. Without this each worker tries to use all CPU cores for
+    numpy / pandas / polars operations, causing N² thread oversubscription
+    and severe slowdowns on Windows/WSL. These env vars must be set
+    before numpy / polars are imported, which is why ``spawn`` is used
+    as the start method (with ``fork`` they would have no effect because
+    those libraries are already loaded in the parent).
     """
-    global _worker_data_provider_service
+    # Pin math library thread pools to 1 thread per worker.
+    for var in (
+        "OMP_NUM_THREADS",
+        "OPENBLAS_NUM_THREADS",
+        "MKL_NUM_THREADS",
+        "NUMEXPR_NUM_THREADS",
+        "VECLIB_MAXIMUM_THREADS",
+        "POLARS_MAX_THREADS",
+    ):
+        os.environ.setdefault(var, "1")
+
+    global _worker_data_provider_service, _worker_progress_counter
     _worker_data_provider_service = data_provider_service
+    _worker_progress_counter = progress_counter
 
 
 def _print_progress(message: str, show_progress: bool = False):
@@ -921,9 +943,13 @@ class BacktestService:
 
                 if use_parallel:
                     # Parallel processing of backtests (batches per worker)
-                    # Determine number of workers
+                    # Determine number of workers. Cap at 8 by default to
+                    # avoid BLAS / IPC contention on Windows/WSL where
+                    # cpu_count() workers is usually slower than fewer.
                     if n_workers == -1:
-                        n_workers = multiprocessing.cpu_count()
+                        n_workers = min(
+                            max(multiprocessing.cpu_count() - 1, 1), 8
+                        )
 
                     # Calculate optimal batch size per worker
                     # Each worker processes a batch of strategies
@@ -948,11 +974,27 @@ class BacktestService:
                             show_progress
                         )
 
-                    # Shared counter for strategy-level progress
-                    # across all workers. Use Manager so the proxy
-                    # object can be pickled by ProcessPoolExecutor.
-                    manager = multiprocessing.Manager()
-                    progress_counter = manager.Value('i', 0)
+                    # Use a single ``spawn`` context for everything.
+                    # On WSL/Linux the default is ``fork`` which copies
+                    # the entire parent process into each worker,
+                    # bloating workers and preventing the BLAS thread
+                    # env vars set in ``_init_worker`` from taking
+                    # effect (numpy/polars are already loaded). With
+                    # ``spawn`` workers start with a clean interpreter
+                    # and those env vars are honoured.
+                    mp_ctx = multiprocessing.get_context("spawn")
+
+                    # Shared counter for strategy-level progress across
+                    # all workers. Use ``mp_ctx.Value`` (shared memory +
+                    # semaphore) instead of ``Manager().Value`` which
+                    # is a proxy that performs an IPC round-trip for
+                    # every read/write through a separate manager
+                    # process. Manager proxies are catastrophically
+                    # slow on Windows/WSL when many workers update the
+                    # same counter, and they also cause the progress
+                    # bar to appear frozen because the monitor thread's
+                    # reads queue behind worker writes.
+                    progress_counter = mp_ctx.Value('i', 0)
 
                     # Copy data provider once and pass via initializer
                     # so each worker inherits it at startup instead of
@@ -974,11 +1016,15 @@ class BacktestService:
                             None,  # placeholder, worker reads global
                             False,
                             dynamic_position_sizing,
-                            progress_counter,
+                            None,  # progress_counter inherited via init
                         ))
 
                     # Start a monitoring thread that updates a
-                    # strategy-level progress bar in real time
+                    # strategy-level progress bar in real time. Use
+                    # mininterval=0 / miniters=1 so the bar refreshes
+                    # promptly on Windows/WSL where stdout is often
+                    # line-buffered and tqdm's default smoothing can
+                    # otherwise make the bar appear frozen.
                     total_strategies = len(strategies_to_run)
                     pbar = tqdm(
                         total=total_strategies,
@@ -987,6 +1033,8 @@ class BacktestService:
                              f"{start_date} to {end_date}",
                         disable=not show_progress,
                         unit="strategy",
+                        mininterval=0,
+                        miniters=1,
                     )
                     stop_event = threading.Event()
 
@@ -994,21 +1042,26 @@ class BacktestService:
                         while not stop_event.is_set():
                             pbar.n = progress_counter.value
                             pbar.refresh()
-                            stop_event.wait(0.5)
+                            stop_event.wait(0.25)
 
                     monitor = threading.Thread(
                         target=_monitor_progress, daemon=True
                     )
                     monitor.start()
 
-                    # Execute batches in parallel.
-                    # Use initializer to pass data_provider_service
-                    # once per worker process rather than pickling it
-                    # with every submitted task.
+                    # Execute batches in parallel using the spawn pool
+                    # created above. The shared ``progress_counter``
+                    # (a ``mp_ctx.Value``) and ``shared_data_provider``
+                    # are passed through the initializer so they are
+                    # inherited once per worker rather than pickled per
+                    # task.
                     with ProcessPoolExecutor(
                         max_workers=n_workers,
+                        mp_context=mp_ctx,
                         initializer=_init_worker,
-                        initargs=(shared_data_provider,),
+                        initargs=(
+                            shared_data_provider, progress_counter,
+                        ),
                     ) as ex:
                         # Submit all batch tasks
                         futures = [
@@ -1066,7 +1119,6 @@ class BacktestService:
                     pbar.n = progress_counter.value
                     pbar.refresh()
                     pbar.close()
-                    manager.shutdown()
 
                     # Save remaining batch and create checkpoint files when
                     # storage directory provided
@@ -1810,6 +1862,12 @@ class BacktestService:
         if data_provider_service is None:
             data_provider_service = _worker_data_provider_service
 
+        # In parallel mode the progress counter is inherited via the
+        # worker initializer (multiprocessing.Value, shared memory).
+        # Fall back to the per-task argument for backward compatibility.
+        if progress_counter is None:
+            progress_counter = _worker_progress_counter
+
         vector_backtest_service = VectorBacktestService(
             data_provider_service=data_provider_service
         )
@@ -1852,9 +1910,12 @@ class BacktestService:
                 batch_results.append(backtest)
 
                 # Increment shared progress counter so the
-                # main process can track per-strategy progress
+                # main process can track per-strategy progress.
+                # ``multiprocessing.Value`` lives in shared memory; the
+                # lock makes ``+= 1`` atomic across workers.
                 if progress_counter is not None:
-                    progress_counter.value += 1
+                    with progress_counter.get_lock():
+                        progress_counter.value += 1
 
             except Exception as e:
                 if continue_on_error:
@@ -1865,7 +1926,8 @@ class BacktestService:
                     # Still increment counter for failed strategies
                     # so progress total stays accurate
                     if progress_counter is not None:
-                        progress_counter.value += 1
+                        with progress_counter.get_lock():
+                            progress_counter.value += 1
                     continue
                 else:
                     raise

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/investing_algorithm_framework/services/__init__.py

@@ -38,7 +38,8 @@ from .metrics import get_annual_volatility, get_mean_daily_return, \
     get_current_win_rate, get_current_average_trade_return, \
     get_current_average_trade_loss, get_current_average_trade_duration, \
     get_current_average_trade_gain, create_backtest_metrics_for_backtest, \
-    recalculate_backtests
+    recalculate_backtests, get_cv_consistency, get_normalized_stability, \
+    get_consistency_score, get_stability_score
 
 __all__ = [
     "get_mean_daily_return",
@@ -134,5 +135,9 @@ __all__ = [
     "recalculate_backtests",
     "TradeStopLossService",
     "TradeTakeProfitService",
-    "get_mean_yearly_return"
+    "get_mean_yearly_return",
+    "get_cv_consistency",
+    "get_normalized_stability",
+    "get_consistency_score",
+    "get_stability_score"
 ]

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/investing_algorithm_framework/services/metrics/__init__.py

@@ -40,6 +40,8 @@ from .trades import get_negative_trades, get_positive_trades, \
     get_average_trade_duration
 from .mean_daily_return import get_mean_daily_return, get_mean_yearly_return
 from .standard_deviation import get_daily_returns_std
+from .consistency import get_cv_consistency, get_normalized_stability, \
+    get_consistency_score, get_stability_score
 
 __all__ = [
     "get_mean_daily_return",
@@ -115,5 +117,9 @@ __all__ = [
     "get_number_of_open_trades",
     "get_average_trade_duration",
     "create_backtest_metrics_for_backtest",
-    "get_mean_yearly_return"
+    "get_mean_yearly_return",
+    "get_cv_consistency",
+    "get_normalized_stability",
+    "get_consistency_score",
+    "get_stability_score"
 ]

investing_algorithm_framework-8.6.0/investing_algorithm_framework/services/metrics/consistency.py

@@ -0,0 +1,13 @@
+from investing_algorithm_framework.domain.backtesting.consistency import (
+    get_cv_consistency,
+    get_normalized_stability,
+    get_consistency_score,
+    get_stability_score,
+)
+
+__all__ = [
+    "get_cv_consistency",
+    "get_normalized_stability",
+    "get_consistency_score",
+    "get_stability_score",
+]

{investing_algorithm_framework-8.5.0 → investing_algorithm_framework-8.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "investing-algorithm-framework"
-version = "v8.5.0"
+version = "v8.6.0"
 description = "A framework for creating trading bots"
 authors = ["MDUYN"]
 readme = "README.md"