Remove post-process

Author: MaxBA1602

EyeFlow.spec

@@ -5,17 +5,14 @@ from PyInstaller.utils.hooks import collect_submodules
 datas = []
 hiddenimports = []
 datas += collect_data_files('pipelines')
-datas += collect_data_files('postprocess')
 datas += collect_data_files('sv_ttk')
 datas += collect_data_files('tkinterdnd2')
 datas += [('EyeFlow_logo.png', '.')]
 datas += [('EyeFlow.ico', '.')]
 datas += [('default_settings.json', '.')]
 datas += [('pyproject.toml', '.')]
 hiddenimports += collect_submodules('pipelines')
-hiddenimports += collect_submodules('postprocess')
 hiddenimports += collect_submodules('tkinterdnd2')
-hiddenimports += ['matplotlib.backends.backend_ps']
 
 
 a = Analysis(

README.md

@@ -35,16 +35,13 @@ pip install -e .
 
 # Installs pipeline-specific dependencies (optional)
 pip install -e ".[pipelines]"
-
-# Installs postprocess-specific dependencies such as the graphics dashboard (optional)
-pip install -e ".[postprocess]"
 ```
 
 ### 2. Development Setup (Contributor)
 
 ```sh
 # Install all dependencies including dev tools (ruff, pre-commit, pyinstaller)
-pip install -e ".[dev,pipelines,postprocess]"
+pip install -e ".[dev,pipelines]"
 
 # Initialize pre-commit hooks (optionnal)
 pre-commit install
@@ -76,10 +73,7 @@ Launch the main application to process files interactively:
 
 The GUI handles batch processing for folders, single .h5/.hdf5 files, or .zip archives and lets you run multiple pipelines at once. Batch outputs preserve the input subfolder layout under the chosen output directory (one combined `.h5` per input file).
 
-You can also select batch-level postprocess steps. These run after the selected pipelines finish and before optional zipping, so any generated dashboards, PNGs, or summaries are included in the final output folder or archive.
-
 Use the Pipeline Library tab to select which pipelines run. Selection preferences are saved per user between app launches, including installed builds.
-Use the Postprocess Library tab the same way for postprocess steps.
 
 ```sh
 # Via the entry point
@@ -91,7 +85,7 @@ python src/eye_flow.py
 
 When you run `eyeflow` from inside the repository checkout, the launcher prefers the local `src/` tree so newly added or edited pipelines are picked up without needing a full reinstall.
 
-Installed builds expose editable `pipelines/` and `postprocess/` folders next to `EyeFlow.exe`; use the Library tabs' Open folder and Reload buttons to edit and refresh them.
+Installed builds expose an editable `pipelines/` folder next to `EyeFlow.exe`; use the Pipeline Library tab's Open folder and Reload buttons to edit and refresh it.
 
 ### CLI
 
@@ -145,54 +139,3 @@ class MyAnalysis(ProcessPipeline):
             attrs=attrs
         )
 ```
-
-## Postprocess System
-
-Postprocess steps are discovered from `src/postprocess/` in the same spirit as pipelines, but they run once per batch over the generated pipeline output folder.
-
-Use `@registerPostprocess(...)` to declare:
-
-- optional Python package dependencies with `required_deps`
-- required pipeline outputs with `required_pipelines`
-
-### Simple Postprocess Structure
-
-```python
-from postprocess.core.base import (
-    BatchPostprocess,
-    PostprocessContext,
-    PostprocessResult,
-    registerPostprocess,
-)
-
-
-@registerPostprocess(
-    name="My Batch Summary",
-    description="Aggregate metrics across the generated batch outputs.",
-    required_pipelines=["Basic Stats"],
-)
-class MyBatchSummary(BatchPostprocess):
-    def run(self, context: PostprocessContext) -> PostprocessResult:
-        report_path = context.output_dir / "my_batch_summary.json"
-        report_path.write_text("{}", encoding="utf-8")
-
-        return PostprocessResult(
-            summary="Generated my_batch_summary.json.",
-            generated_paths=[str(report_path)],
-            metadata={"file_count": len(context.processed_files)},
-        )
-```
-
-Inside a postprocess, you can:
-
-- read `context.output_dir`
-- read `context.processed_files`
-- read `context.selected_pipelines`
-- read `context.input_path`
-- read `context.zip_outputs`
-- write extra artifacts into `context.output_dir` before optional zipping
-- return a short `summary`, explicit `generated_paths`, and structured `metadata`
-
-The included `Graphics Dashboard` postprocess shows the intended pattern: it consumes the `arterial_waveform_shape_metrics` output and generates a cohort dashboard plus PNG exports after the batch finishes.
-`Pipeline Metrics Manifest` is a lighter built-in example that writes a JSON inventory of the generated pipeline metric datasets for the batch.
-`Postprocess Tutorial` is the minimal reference example: it writes a single JSON file showing every `PostprocessContext` field and the `PostprocessResult` output format.

default_settings.json

@@ -7,13 +7,6 @@
     "waveform_harmonic_organization_SVD": false,
     "waveform_shape_metrics": true
   },
-  "postprocess_visibility": {
-    "Pipeline Metrics Manifest": false,
-    "Postprocess Tutorial": false,
-    "QC_Windkessel_RC": false,
-    "Variability and heterogeneity tables": false,
-    "groups comparison dashboard": false
-  },
   "trim_h5source": true,
   "ui_mode": "minimal"
 }

hooks/hook-postprocess.py

@@ -17,7 +17,6 @@ dependencies = ["numpy>=1.24", "h5py>=3.9", "sv-ttk>=2.6", "tkinterdnd2"]
 [project.optional-dependencies]
 # For specific pipelines
 pipelines = ["torch>=2.2", "pandas>=2.1"]
-postprocess = ["matplotlib>=3.8", "pandas>=2.1", "plotly>=5.18"]
 
 # For developers
 dev = ["ruff", "pre-commit", "pyinstaller"]

pyproject.toml

@@ -137,12 +137,6 @@ def normalize_pipeline_visibility(
     return normalize_named_visibility(pipeline_names, stored_visibility)
 
 
-def normalize_postprocess_visibility(
-    postprocess_names: Iterable[str], stored_visibility: Mapping[str, bool] | None
-) -> tuple[dict[str, bool], bool]:
-    return normalize_named_visibility(postprocess_names, stored_visibility)
-
-
 class AppSettingsStore:
     def __init__(
         self,
@@ -207,12 +201,6 @@ def load_pipeline_visibility(self) -> dict[str, bool]:
     def save_pipeline_visibility(self, visibility: Mapping[str, bool]) -> None:
         self.save_named_visibility("pipeline_visibility", visibility)
 
-    def load_postprocess_visibility(self) -> dict[str, bool]:
-        return self.load_named_visibility("postprocess_visibility")
-
-    def save_postprocess_visibility(self, visibility: Mapping[str, bool]) -> None:
-        self.save_named_visibility("postprocess_visibility", visibility)
-
     def load_ui_mode(self) -> str:
         mode = self.load().get("ui_mode")
         return mode if mode in {"minimal", "advanced"} else "minimal"

src/app_settings.py

@@ -2,12 +2,11 @@
 Command-line interface to run EyeFlow pipelines over a collection of HDF5 files.
 
 Usage example:
-    python cli.py --data data/ --pipelines pipelines.txt --postprocess postprocess.txt --output ./results --zip --zip-name my_run.zip
+    python cli.py --data data/ --pipelines pipelines.txt --output ./results --zip --zip-name my_run.zip
 
 Inputs:
     --data / -d        Path to a directory (recursively scanned), a single .h5/.hdf5 file, or a .zip archive of .h5 files.
     --pipelines / -p   Text file listing pipeline names (one per line, '#' and blank lines ignored).
-    --postprocess      Optional text file listing postprocess names (one per line, '#' and blank lines ignored).
     --output / -o      Base directory where results will be written (input subfolder layout is preserved).
     --zip / -z         When set, compress the outputs into a .zip archive after completion.
     --zip-name         Optional filename for the archive (default: outputs.zip).
@@ -33,22 +32,11 @@
 )
 from pipelines.core.errors import format_pipeline_exception
 from pipelines.core.utils import write_combined_results_h5
-from postprocess import (
-    PostprocessContext,
-    PostprocessDescriptor,
-    load_postprocess_catalog,
-)
 
 
 def _build_pipeline_registry() -> dict[str, PipelineDescriptor]:
     available, _ = load_pipeline_catalog()
-    # pipelines = load_all_pipelines()
-    return {p.name: p for p in available}
-
-
-def _build_postprocess_registry() -> dict[str, PostprocessDescriptor]:
-    available, _ = load_postprocess_catalog()
-    return {p.name: p for p in available}
+    return {pipeline.name: pipeline for pipeline in available}
 
 
 def _load_pipeline_list(
@@ -78,48 +66,6 @@ def _load_pipeline_list(
     return selected
 
 
-def _load_postprocess_list(
-    path: Path, registry: dict[str, PostprocessDescriptor]
-) -> list[PostprocessDescriptor]:
-    raw_lines = path.read_text(encoding="utf-8").splitlines()
-    selected: list[PostprocessDescriptor] = []
-    missing: list[str] = []
-    for line in raw_lines:
-        name = line.strip()
-        if not name or name.startswith("#"):
-            continue
-        postprocess = registry.get(name)
-        if postprocess is None:
-            missing.append(name)
-        else:
-            selected.append(postprocess)
-    if missing:
-        available = ", ".join(registry.keys())
-        raise ValueError(
-            f"Unknown postprocess step(s): {', '.join(missing)}. Available: {available}"
-        )
-    return selected
-
-
-def _validate_postprocess_selection(
-    postprocesses: Sequence[PostprocessDescriptor],
-    selected_pipeline_names: Sequence[str],
-) -> None:
-    selected_set = set(selected_pipeline_names)
-    errors = []
-    for postprocess in postprocesses:
-        missing_required = [
-            name for name in postprocess.required_pipelines if name not in selected_set
-        ]
-        if missing_required:
-            errors.append(
-                f"{postprocess.name} requires pipeline(s): "
-                f"{', '.join(missing_required)}"
-            )
-    if errors:
-        raise ValueError("\n".join(errors))
-
-
 def _find_h5_inputs(path: Path) -> list[Path]:
     if path.is_file():
         if path.suffix.lower() in {".h5", ".hdf5"}:
@@ -131,13 +77,6 @@ def _find_h5_inputs(path: Path) -> list[Path]:
     raise FileNotFoundError(f"Input path does not exist: {path}")
 
 
-def _safe_pipeline_suffix(name: str) -> str:
-    cleaned = "".join(ch if ch.isalnum() else "_" for ch in name.lower())
-    while "__" in cleaned:
-        cleaned = cleaned.replace("__", "_")
-    return cleaned.strip("_") or "pipeline"
-
-
 def _prepare_data_root(
     data_path: Path,
 ) -> tuple[Path, tempfile.TemporaryDirectory | None]:
@@ -230,23 +169,12 @@ def _zip_output_dir(
 def run_cli(
     data_path: Path,
     pipelines_file: Path,
-    postprocess_file: Path | None,
     output_dir: Path,
     zip_outputs: bool = False,
     zip_name: str | None = None,
 ) -> int:
     registry = _build_pipeline_registry()
     pipelines = _load_pipeline_list(pipelines_file, registry)
-    postprocess_registry = _build_postprocess_registry()
-    postprocesses = (
-        _load_postprocess_list(postprocess_file, postprocess_registry)
-        if postprocess_file is not None
-        else []
-    )
-    _validate_postprocess_selection(
-        postprocesses,
-        selected_pipeline_names=[pipeline.name for pipeline in pipelines],
-    )
     data_root, tempdir = _prepare_data_root(data_path)
     work_tempdir_path: Path | None = None
     clean_work_output = False
@@ -279,37 +207,6 @@ def run_cli(
                 failures.append(f"{h5_path}: {exc}")
                 print(f"[FAIL] {h5_path.name}: {exc}", file=sys.stderr)
 
-        if postprocesses and processed_outputs:
-            context = PostprocessContext(
-                output_dir=work_root,
-                processed_files=tuple(processed_outputs),
-                selected_pipelines=tuple(pipeline.name for pipeline in pipelines),
-                input_path=data_path,
-                zip_outputs=zip_outputs,
-            )
-            for descriptor in postprocesses:
-                print(f"[POST] Running {descriptor.name}...")
-                try:
-                    result = descriptor.instantiate().run(context)
-                except Exception as exc:  # noqa: BLE001
-                    msg = (
-                        f"Postprocess '{descriptor.name}' failed: "
-                        f"{type(exc).__name__}: {exc}"
-                    )
-                    failures.append(msg)
-                    print(f"[POST FAIL] {msg}", file=sys.stderr)
-                    continue
-                if result.summary:
-                    print(f"[POST OK] {descriptor.name}: {result.summary}")
-                else:
-                    print(f"[POST OK] {descriptor.name}")
-        elif postprocesses:
-            print(
-                "[POST SKIP] No successful pipeline outputs were generated, "
-                "so postprocess steps were skipped.",
-                file=sys.stderr,
-            )
-
         if zip_outputs:
             try:
                 final_name = (zip_name or "outputs.zip").strip() or "outputs.zip"
@@ -340,7 +237,10 @@ def _zip_progress(done: int, total: int, _rel_path: Path) -> None:
                 )
                 summary_msg = f"Outputs stored under: {work_root}"
         else:
-            summary_msg = f"Outputs stored under: {work_root}"
+            if len(processed_outputs) == 1:
+                summary_msg = f"Output file: {processed_outputs[0]}"
+            else:
+                summary_msg = f"Outputs stored under: {work_root}"
 
         print(f"Completed. {summary_msg}")
 
@@ -375,12 +275,6 @@ def main(argv: Sequence[str] | None = None) -> int:
         type=Path,
         help="Text file with pipeline names to run (one per line, '#' and blank lines ignored).",
     )
-    parser.add_argument(
-        "--postprocess",
-        type=Path,
-        default=None,
-        help="Optional text file with postprocess names to run after pipelines.",
-    )
     parser.add_argument(
         "-o",
         "--output",
@@ -406,7 +300,6 @@ def main(argv: Sequence[str] | None = None) -> int:
         return run_cli(
             args.data,
             args.pipelines,
-            args.postprocess,
             args.output,
             zip_outputs=args.zip,
             zip_name=args.zip_name,