Add strong regression unit tests

.pre-commit-config.yaml

@@ -2,14 +2,14 @@
 repos:
 # Ruff
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.15.16
+  rev: v0.16.1
   hooks:
   - id: ruff
     args: ["--fix"]
   - id: ruff-format
 # https://pycqa.github.io/isort/docs/configuration/black_compatibility.html#integration-with-pre-commit
 - repo: https://github.com/pycqa/isort
-  rev: 9.0.0a3
+  rev: 9.0.0b1
   hooks:
   - id: isort
     args: ["--profile", "black", "--filter-files"]
@@ -34,7 +34,7 @@ repos:
     #  - id: actionlint
 # codespell
 - repo: https://github.com/codespell-project/codespell
-  rev: v2.4.2
+  rev: v2.4.3
   hooks:
   - id: codespell
     args: [

docs/changes/80.maintenance.md

@@ -0,0 +1 @@
+Add strong testing for regression path.

pyproject.toml

@@ -93,6 +93,7 @@ indent-width = 4
 exclude = [
   "__init__.py",
   "pyproject.toml",
+  "tests/",
 ]
 
 format.indent-style = "space"
@@ -132,9 +133,6 @@ lint.ignore = [
 
 lint.pydocstyle.convention = "numpy"
 
-[tool.ruff.lint.per-file-ignores]
-"tests/**.py" = ["D103"]
-
 [tool.codespell]
 ignore-words-list = "chec,arrang,livetime"
 

src/eventdisplay_ml/data_processing.py

@@ -824,7 +824,9 @@ def _flatten_training_chunk(
         disp_erec = df_flat["ErecS"].values
 
         # Compute log energies (ErecS already filtered > 0)
-        mc_e0_log = np.where(mc_e0 > 0, np.log10(mc_e0), np.nan)
+        mc_e0_log = np.full_like(mc_e0, np.nan, dtype=np.float32)
+        valid_mc_energy = mc_e0 > 0
+        mc_e0_log[valid_mc_energy] = np.log10(mc_e0[valid_mc_energy])
         disp_erec_log = np.log10(disp_erec)  # Safe since already filtered > 0
 
         new_cols = {

src/eventdisplay_ml/models.py

@@ -283,7 +283,7 @@ def _validate_energy_bin_metadata(energy_bin, model_file):
         Validated metadata containing ``E_min`` and ``E_max`` keys.
     """
     if not isinstance(energy_bin, dict):
-        raise ValueError(
+        raise TypeError(
             "Classification model file "
             f"'{model_file}' has invalid 'energy_bins_log10_tev' metadata: "
             "expected a dict with keys 'E_min' and 'E_max'."
@@ -601,7 +601,7 @@ def process_file_chunked(analysis_type, model_configs):
             {
                 eff
                 for e_bin_models in model_configs["models"].values()
-                for eff in (e_bin_models.get("thresholds") or {}).keys()
+                for eff in (e_bin_models.get("thresholds") or {})
             }
         )
 

src/eventdisplay_ml/scripts/diagnostic_shap_summary.py

@@ -156,8 +156,8 @@ def main():
             output_file = utils.joblib_basename(model_path)
             try:
                 process_model_file(model_path, output_dir, output_file)
-            except Exception as e:
-                _logger.exception(f"Skipping {model_path}: failed to process model ({e})")
+            except Exception:
+                _logger.exception(f"Skipping {model_path}: failed to process model")
                 continue
 
     _logger.info(f"\nPlots saved to {output_dir}")

src/eventdisplay_ml/scripts/optimize_classification.py

@@ -142,7 +142,7 @@ def _extract_tgraph2d(graph):
     try:
         x, y, z = graph.values()
         return np.asarray(x), np.asarray(y), np.asarray(z)
-    except Exception:
+    except (AttributeError, ValueError, TypeError):
         x = np.asarray(graph.member("fX"))
         y = np.asarray(graph.member("fY"))
         z = np.asarray(graph.member("fZ"))

src/eventdisplay_ml/scripts/plot_classification_gamma_efficiency.py

@@ -70,7 +70,7 @@ def get_containment_data(directory):
                 _logger.info(f"Percentiles p70: {p70}, p95: {p95}")
             else:
                 _logger.warning("Nan percentiles")
-        except Exception as e:
+        except (OSError, ValueError, KeyError) as e:
             _logger.error(f"Failed reading {filename}: {e}")
 
     return pd.DataFrame(results)

src/eventdisplay_ml/scripts/plot_training_evaluation.py

@@ -131,7 +131,7 @@ def main():
         type=str,
         help=(
             "Directory containing multiple joblib model files. "
-            "All *.joblib files will be processed.",
+            "All *.joblib files will be processed."
         ),
     )
     parser.add_argument(
@@ -218,8 +218,8 @@ def main():
                 )
                 plot_training_curves(evals_result, output_file)
                 _logger.info(f"Saved plot for {model_path.name} to {output_file}")
-            except Exception as e:
-                _logger.exception(f"Skipping {model_path}: failed to process model ({e})")
+            except Exception:
+                _logger.exception(f"Skipping {model_path}: failed to process model")
                 continue
 
         _logger.info("Batch plotting completed.")

src/eventdisplay_ml/utils.py

@@ -88,7 +88,11 @@ def discover_joblib_files(model_dir):
     if not model_dir.exists() or not model_dir.is_dir():
         raise FileNotFoundError(f"Model directory not found: {model_dir}")
 
-    discovered_files = sorted(set(model_dir.glob("*.joblib")).union(model_dir.glob("*.joblib.gz")))
+    discovered_files = sorted(
+        path
+        for path in set(model_dir.glob("*.joblib")).union(model_dir.glob("*.joblib.gz"))
+        if path.is_file()
+    )
     files_by_name = {}
     for model_path in discovered_files:
         key = joblib_basename(model_path)

tests/scripts/test_stereo_entrypoints.py

@@ -0,0 +1,87 @@
+"""Unit tests for production stereo-regression console-script wiring."""
+
+from unittest.mock import MagicMock
+
+import pandas as pd
+import pytest
+
+from eventdisplay_ml.scripts import apply_xgb_stereo, train_xgb_stereo
+
+
+def test_train_stereo_entrypoint_runs_the_complete_regression_pipeline(monkeypatch, caplog):
+    """The training CLI must connect configuration, loading, training, and saving unchanged."""
+    caplog.set_level("INFO")
+    configured = {"input_file_list": "gamma_inputs.txt", "model_prefix": "stereo_model"}
+    loaded_data = pd.DataFrame({"feature": [1.0]})
+    trained = {"model_prefix": "stereo_model", "models": {"xgboost": {"model": object()}}}
+    configure = MagicMock(return_value=configured)
+    load_data = MagicMock(return_value=loaded_data)
+    train = MagicMock(return_value=trained)
+    save = MagicMock()
+    monkeypatch.setattr(train_xgb_stereo, "configure_training", configure)
+    monkeypatch.setattr(train_xgb_stereo, "load_training_data", load_data)
+    monkeypatch.setattr(train_xgb_stereo, "train_regression", train)
+    monkeypatch.setattr(train_xgb_stereo, "save_models", save)
+
+    train_xgb_stereo.main()
+
+    configure.assert_called_once_with("stereo_analysis")
+    load_data.assert_called_once_with(configured, "gamma_inputs.txt", "stereo_analysis")
+    train.assert_called_once_with(loaded_data, configured)
+    save.assert_called_once_with(trained)
+    assert "stereo_analysis model trained successfully" in caplog.text
+
+
+def test_train_stereo_entrypoint_does_not_save_when_regression_training_fails(monkeypatch):
+    """A failed regression fit must propagate and never create a partial artifact."""
+    configured = {"input_file_list": "gamma_inputs.txt"}
+    save = MagicMock()
+    monkeypatch.setattr(train_xgb_stereo, "configure_training", lambda *_args: configured)
+    monkeypatch.setattr(
+        train_xgb_stereo, "load_training_data", lambda *_args: pd.DataFrame({"feature": [1.0]})
+    )
+    monkeypatch.setattr(
+        train_xgb_stereo,
+        "train_regression",
+        lambda *_args: (_ for _ in ()).throw(RuntimeError("fit failed")),
+    )
+    monkeypatch.setattr(train_xgb_stereo, "save_models", save)
+
+    with pytest.raises(RuntimeError, match="fit failed"):
+        train_xgb_stereo.main()
+
+    save.assert_not_called()
+
+
+def test_apply_stereo_entrypoint_passes_the_loaded_configuration_to_streaming(monkeypatch):
+    """The apply CLI must select stereo analysis and preserve loaded model metadata."""
+    configured = {
+        "models": {"xgboost": {"model": object()}},
+        "target_mean": {"Xoff_residual": 0.0},
+        "target_std": {"Xoff_residual": 1.0},
+    }
+    configure = MagicMock(return_value=configured)
+    process = MagicMock()
+    monkeypatch.setattr(apply_xgb_stereo, "configure_apply", configure)
+    monkeypatch.setattr(apply_xgb_stereo, "process_file_chunked", process)
+
+    apply_xgb_stereo.main()
+
+    configure.assert_called_once_with("stereo_analysis")
+    process.assert_called_once_with("stereo_analysis", configured)
+
+
+def test_apply_stereo_entrypoint_does_not_stream_when_configuration_fails(monkeypatch):
+    """Invalid model configuration must stop before input ROOT data are processed."""
+    process = MagicMock()
+    monkeypatch.setattr(
+        apply_xgb_stereo,
+        "configure_apply",
+        lambda *_args: (_ for _ in ()).throw(ValueError("missing target_std")),
+    )
+    monkeypatch.setattr(apply_xgb_stereo, "process_file_chunked", process)
+
+    with pytest.raises(ValueError, match="missing target_std"):
+        apply_xgb_stereo.main()
+
+    process.assert_not_called()

tests/test_models_helpers.py

@@ -136,7 +136,9 @@ def test_load_classification_models_rejects_missing_energy_bin_metadata(tmp_path
         tmp_path / "model_ebin0.joblib",
     )
 
-    with pytest.raises(ValueError, match=r"model_ebin0\.joblib.*energy_bins_log10_tev"):
+    with pytest.raises(
+        (ValueError, TypeError), match=r"model_ebin0\.joblib.*energy_bins_log10_tev"
+    ):
         models.load_classification_models(str(prefix), "xgboost")
 
 
@@ -367,12 +369,14 @@ def test_process_file_chunked_uses_tmva_style_features_when_flag_set():
     def fake_open(path):
         raise RuntimeError("uproot not needed for this assertion")
 
-    with patch("eventdisplay_ml.models.uproot.open", side_effect=fake_open):
-        with pytest.raises(RuntimeError, match="uproot not needed"):
-            models.process_file_chunked(
-                "classification",
-                {"tmva_style": True, "input_file": "dummy.root"},
-            )
+    with (
+        patch("eventdisplay_ml.models.uproot.open", side_effect=fake_open),
+        pytest.raises(RuntimeError, match="uproot not needed"),
+    ):
+        models.process_file_chunked(
+            "classification",
+            {"tmva_style": True, "input_file": "dummy.root"},
+        )
 
     # Verify that tmva_style features differ from regular features
     assert set(expected) != set(regular_features)