feat: add NoResetBenchmarkRunner

Author: iraedeus

pysatl_cpd/benchmark/noreset/noreset_benchmark_runner.py

@@ -1,8 +1,24 @@
+# -*- coding: ascii -*-
+
+"""
+NoReset benchmark runner implementation.
+
+This module provides NoResetBenchmarkRunner - an optimised benchmark for
+series with a single change point. The solver is executed only once per
+(algorithm, provider) pair with threshold=inf, and all threshold
+evaluations are simulated via ThresholdPolicy on the cached trace.
+"""
+
+__author__ = "Danil Totmyanin"
+__copyright__ = "Copyright (c) 2026 PySATL project"
+__license__ = "SPDX-License-Identifier: MIT"
+
 from collections.abc import Sequence
 from pathlib import Path
 from typing import Any
 
 from pysatl_cpd.analysis.labeled_data import LabeledData
+from pysatl_cpd.benchmark.core.benchmark_executor import BenchmarkExecutor
 from pysatl_cpd.benchmark.metrics.multiple_run_metric import MultipleRunMetric
 from pysatl_cpd.benchmark.noreset.noreset_detection_trace import NoResetDetectionTrace
 from pysatl_cpd.benchmark.noreset.threshold_policy import ThresholdPolicy
@@ -13,28 +29,130 @@
 
 
 class NoResetBenchmarkRunner[ProviderT: LabeledData[Any]](OnlineBenchmarkRunner[NoResetDetectionTrace[Any], ProviderT]):
+    """
+    Optimised benchmark runner for series with a single change point.
+
+    For each (algorithm, provider) pair the solver is executed exactly
+    once with threshold=inf, producing a full detection function trace.
+    All threshold evaluations are then simulated by applying a
+    ThresholdPolicy to that cached trace, avoiding redundant solver runs.
+    Caching is handled entirely by BenchmarkExecutor.
+
+    Parameters
+    ----------
+    algorithms : Sequence[tuple[OnlineAlgorithm[Any, Any, Any], Sequence[float]]]
+        Sequence of (algorithm, thresholds) pairs to evaluate.
+    providers : Sequence[ProviderT]
+        Labeled data providers to run against.
+    metrics : dict[str, MultipleRunMetric[NoResetDetectionTrace[Any], ProviderT, Any]]
+        Named metrics to evaluate for each (algorithm, threshold) batch.
+    solver : OnlineCpdSolver
+        Solver used to produce inf traces.
+    policy : ThresholdPolicy
+        Policy used to extract detected change points from the inf trace
+        for each threshold.
+    dump_dir : Path | str | None, optional
+        Directory for caching inf traces via BenchmarkExecutor.
+        If None, caching is disabled. Default is None.
+    """
+
     def __init__(
         self,
         algorithms: Sequence[tuple[OnlineAlgorithm[Any, Any, Any], Sequence[float]]],
         providers: Sequence[ProviderT],
         metrics: dict[str, MultipleRunMetric[NoResetDetectionTrace[Any], ProviderT, Any]],
         solver: OnlineCpdSolver,
         policy: ThresholdPolicy,
-        dump_dir: Path | None = None,
+        dump_dir: Path | str | None = None,
     ) -> None:
-        return
+        super().__init__(
+            algorithms=algorithms,
+            providers=providers,
+            metrics=metrics,
+            solver=solver,
+            dump_dir=dump_dir,
+        )
+        self._policy = policy
+
+    def _get_inf_trace(
+        self,
+        algorithm: OnlineAlgorithm[Any, Any, Any],
+        provider: ProviderT,
+    ) -> OnlineDetectionTrace[Any]:
+        """
+        Compute or retrieve the infinite-threshold trace for a given pair.
+
+        Delegates entirely to BenchmarkExecutor which handles disk caching
+        when dump_dir is set.
+
+        Parameters
+        ----------
+        algorithm : OnlineAlgorithm[Any, Any, Any]
+            The algorithm to run.
+        provider : ProviderT
+            The data provider to run against.
+
+        Returns
+        -------
+        OnlineDetectionTrace[Any]
+            Trace produced with threshold=inf.
+        """
+        executor: BenchmarkExecutor[Any] = BenchmarkExecutor(
+            algorithms=[(algorithm, [float("inf")])],
+            providers=[provider],
+            solver=self._solver,
+            dump_dir=self._dump_dir,
+        )
+        _, inf_trace = executor.execute()[0]
+        return inf_trace
 
     def _collect_runs(
         self,
         algorithm: OnlineAlgorithm[Any, Any, Any],
         threshold: float,
         providers: Sequence[ProviderT],
     ) -> list[tuple[NoResetDetectionTrace[Any], ProviderT]]:
-        raise NotImplementedError("Method '_collect_runs' is not implemented yet.")
+        """
+        Collect NoReset runs for a given algorithm and threshold.
 
-    def _get_inf_trace(
-        self,
-        algorithm: OnlineAlgorithm[Any, Any, Any],
-        provider: ProviderT,
-    ) -> OnlineDetectionTrace[Any]:
-        raise NotImplementedError("Method '_get_inf_trace' is not implemented yet.")
+        For each provider, retrieves the inf trace via BenchmarkExecutor
+        and applies the ThresholdPolicy to produce a lightweight
+        NoResetDetectionTrace.
+
+        Parameters
+        ----------
+        algorithm : OnlineAlgorithm[Any, Any, Any]
+            The algorithm to evaluate.
+        threshold : float
+            The detection threshold to simulate.
+        providers : Sequence[ProviderT]
+            Data providers to run against.
+
+        Returns
+        -------
+        list[tuple[NoResetDetectionTrace[Any], ProviderT]]
+            List of (noreset_trace, provider) pairs, one per provider.
+        """
+        if not providers:
+            return []
+
+        runs: list[tuple[NoResetDetectionTrace[Any], ProviderT]] = []
+
+        for provider in providers:
+            inf_trace = self._get_inf_trace(algorithm, provider)
+
+            detected_change_points: list[int] = self._policy.apply(
+                inf_trace.detection_function,
+                threshold,
+                provider.change_points,
+            )
+
+            noreset_trace = NoResetDetectionTrace.from_inf_trace(
+                source_trace=inf_trace,
+                detected_change_points=detected_change_points,
+                threshold=threshold,
+            )
+
+            runs.append((noreset_trace, provider))
+
+        return runs

tests/mocks/algorithms/online/error.py

@@ -168,7 +168,5 @@ def __repr__(self) -> str:
         return (
             f"{self.__class__.__name__}("
             f"name={self._name!r}, "
-            f"error_on_call={self._error_on_call}, "
             f"learning_period_size={self._config.learning_period_size}, "
-            f"process_count={self._process_count})"
         )

tests/mocks/algorithms/online/simple.py

@@ -155,5 +155,4 @@ def __repr__(self) -> str:
             f"{self.__class__.__name__}("
             f"name={self._name!r}, "
             f"learning_period_size={self._config.learning_period_size}, "
-            f"process_count={self._process_count})"
         )

tests/mocks/analysis/labeled_data.py

@@ -35,3 +35,32 @@ def __init__(self, change_points: Sequence[int], name: str = "MockLabeledData"):
         max_idx = max(change_points) if change_points else 0
         dummy_raw_data = [0.0] * max_idx
         super().__init__(raw_data=dummy_raw_data, change_points=change_points, name=name)
+
+
+class MockLabeledDataWithPadding(LabeledData[float]):
+    """
+    Mock LabeledData where raw data length exceeds the maximum change point index.
+
+    Unlike MockLabeledData (where len == max_cp), this mock adds padding so
+    that the last observation index is not a change point. This prevents
+    algorithms from producing detections at index 0 due to insufficient data.
+
+    Parameters
+    ----------
+    change_points : Sequence[int]
+        Known change point indices (1-based, must be positive).
+    padding : int, default=10
+        Number of extra observations to append after the last change point.
+    name : str, default="MockLabeledDataWithPadding"
+        Dataset identifier.
+    """
+
+    def __init__(
+        self,
+        change_points: Sequence[int],
+        padding: int = 10,
+        name: str = "MockLabeledDataWithPadding",
+    ) -> None:
+        max_idx = max(change_points) if change_points else 0
+        dummy_raw_data = [0.0] * (max_idx + padding)
+        super().__init__(raw_data=dummy_raw_data, change_points=change_points, name=name)