feat(backtest): make checkpoints content-aware + add force_rerun (#276)

Closes #276

- New checkpoint_manifest module computes a manifest_hash from each
  strategy's source code, instance parameters, data sources, and
  backtest date range.
- BacktestService.run_vector_backtests and run_backtests now compute
  manifest hashes for active strategies/algorithms and persist them in
  checkpoints.json. Strategies whose hash differs from the stored hash
  are rerun automatically; matching ones are still skipped.
- Both methods accept two new explicit, non-interactive override knobs:
    * force_rerun: bool | 'stale' = False
    * on_checkpoint_match: 'skip' | 'rerun' | 'warn' = 'skip'
  These are wired through App.run_vector_backtests and App.run_backtests.
- checkpoints.json now supports both legacy list and dict shapes.
  Old files keep working (hash treated as None = legacy behaviour);
  new runs migrate the entry to dict {algorithm_id: manifest_hash}.
- Adds 22 new unit tests covering hash determinism, parameter changes,
  date-range changes, legacy/new entry handling, force_rerun=True,
  on_checkpoint_match='rerun', and dict-format persistence.

Author: MDUYN

investing_algorithm_framework/app/app.py

@@ -4,7 +4,7 @@
 import threading
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
-from typing import List, Optional, Any, Dict, Tuple, Callable, Union
+from typing import List, Literal, Optional, Any, Dict, Tuple, Callable, Union
 
 from flask import Flask
 
@@ -985,6 +985,8 @@ def run_vector_backtests(
         ] = None,
         backtest_storage_directory: Optional[Union[str, Path]] = None,
         use_checkpoints: bool = False,
+        force_rerun: Union[bool, Literal["stale"]] = False,
+        on_checkpoint_match: Literal["skip", "rerun", "warn"] = "skip",
         batch_size: int = 50,
         checkpoint_batch_size: int = 25,
         n_workers: Optional[int] = None,
@@ -1087,7 +1089,24 @@ def filter_function(
                 instead of running a new backtest. This is useful for
                 long-running backtests that might take a while to complete.
                 When enabled, uses the optimized version with batching and
-                optional parallel processing.
+                optional parallel processing. Checkpoints are content-aware:
+                each entry stores a manifest hash that fingerprints the
+                strategy code, parameters, data sources, and date range.
+                Strategies whose hash differs from the stored hash are
+                rerun automatically.
+            force_rerun (Union[bool, Literal["stale"]]): Override checkpoint
+                skipping behaviour.
+
+                - False (default): Skip strategies with a matching checkpoint.
+                - "stale": Rerun only strategies whose stored checkpoint hash
+                  differs from the current manifest hash.
+                - True: Ignore checkpoints entirely and rerun all strategies.
+            on_checkpoint_match (Literal["skip", "rerun", "warn"]): Behaviour
+                when a strategy's checkpoint matches.
+
+                - "skip" (default): Silently skip the strategy.
+                - "warn": Skip but emit a single log line per match batch.
+                - "rerun": Rerun the strategy anyway.
             batch_size (int): Number of strategies to process in each batch
                 before memory cleanup. Only used when use_checkpoints=True.
                 Default: 100. Higher values use more memory but may be faster.
@@ -1204,6 +1223,8 @@ def filter_function(
             checkpoint_batch_size=checkpoint_batch_size,
             n_workers=n_workers,
             use_checkpoints=use_checkpoints,
+            force_rerun=force_rerun,
+            on_checkpoint_match=on_checkpoint_match,
             dynamic_position_sizing=dynamic_position_sizing,
             fill_missing_data=fill_missing_data,
             iterative_summary_update=iterative_summary_update,
@@ -1381,6 +1402,8 @@ def run_backtests(
         metadata: Optional[Dict[str, str]] = None,
         backtest_storage_directory: Optional[Union[str, Path]] = None,
         use_checkpoints: bool = False,
+        force_rerun: Union[bool, Literal["stale"]] = False,
+        on_checkpoint_match: Literal["skip", "rerun", "warn"] = "skip",
         show_progress: bool = False,
         continue_on_error: bool = False,
         window_filter_function: Optional[Callable] = None,
@@ -1420,7 +1443,16 @@ def run_backtests(
             backtest_storage_directory (Union[str, Path]): Directory to save
                 backtests to.
             use_checkpoints (bool): Whether to use checkpointing to resume
-                interrupted backtests.
+                interrupted backtests. Checkpoints are content-aware:
+                strategies whose code or parameters have changed since the
+                last run are detected and rerun automatically.
+            force_rerun (Union[bool, Literal["stale"]]): Override checkpoint
+                skipping behaviour. ``False`` (default) skips matched
+                checkpoints, ``"stale"`` reruns only mismatched ones, and
+                ``True`` reruns everything.
+            on_checkpoint_match (Literal["skip", "rerun", "warn"]): Behaviour
+                on a matching checkpoint. ``"skip"`` (default) silently
+                skips, ``"warn"`` skips and logs, ``"rerun"`` reruns anyway.
             show_progress (bool): Whether to show progress bars.
             continue_on_error (bool): Whether to continue on errors.
             window_filter_function: Filter function applied after each
@@ -1533,6 +1565,8 @@ def run_backtests(
             final_filter_function=final_filter_function,
             backtest_storage_directory=backtest_storage_directory,
             use_checkpoints=use_checkpoints,
+            force_rerun=force_rerun,
+            on_checkpoint_match=on_checkpoint_match,
             batch_size=batch_size,
             checkpoint_batch_size=checkpoint_batch_size,
             fill_missing_data=fill_missing_data,