batch2p 0.1.0__tar.gz

batch2p-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+/scratches/
+/.idea
+.venv

batch2p-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

batch2p-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: batch2p
+Version: 0.1.0
+Author: Francesco P. Battaglia
+License-Expression: GPL-3.0-or-later
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Requires-Dist: pynapple
+Requires-Dist: suite2p
+Requires-Dist: tifffile
+Requires-Dist: tifftrim
+Requires-Dist: totalsync-2p
+Requires-Dist: totalsync-utils
+Provides-Extra: gui
+Requires-Dist: pyqt5; extra == 'gui'

batch2p-0.1.0/README.md

@@ -0,0 +1,72 @@
+# batch2p
+
+Batch 2-photon preprocessing pipeline. Runs configurable source extraction (suite2p or suite3d) from a single JSON configuration file.
+
+
+This package streamlines source extraction from tiff files (at the moment ScanImage files are supported). [Suite2p](https://suite2p.readthedocs.io/en/latest/) and [Suite3d](https://github.com/alihaydaroglu/suite3d/)
+are currently supported, with features like: 
+- file concatenation 
+- flexible parameters handling (also including parameter "sweeps")
+- creation of batch files for SLURM
+- if the experiment used [totalsync](https://github.com/NeuroNetMem/totalsync) for synchronization, imaging and other experimental data (eg. behavioral) are automatically synchronized.
+## Installation
+
+### From PyPI
+
+```bash
+pip install batch2p
+```
+
+### From source (using pip)
+
+```bash
+git clone https://github.com/NeuroNetMem/batch2p.git
+cd batch2p
+pip install . # (or uv pip install ".[all]" )
+```
+
+this will install batch2p without GUI support, (which is suitable for headless servers). To install the GUI, replace the last line with
+```bash
+pip install ".[gui]" # (or uv pip install ".[gui]" )
+```
+
+### From source (using uv)
+
+```bash
+git clone https://github.com/NeuroNetMem/batch2p.git
+cd batch2p
+uv pip install .
+```
+
+### suite3d (optional)
+
+If you need suite3d support, install it manually from source **after** installing batch2p. See instructions at https://github.com/alihaydaroglu/suite3d. 
+
+Briefly, 
+
+- Clone the suite3d repository (in a different directory):
+
+```bash
+git clone https://github.com/alihaydaroglu/suite3d.git
+```
+
+```bash
+cd suite3d 
+pip install ".[all]" # (or uv pip install ".[all]" )
+```
+
+Then, install the suite3d cuda dependencies:
+
+```bash
+pip install "cupy-cuda13x" # for CUDA 13.X, for other CUDA versions change accordingly
+```
+
+
+
+## Usage
+
+Detailed usage documentation can be found in the [docs](docs) directory.
+
+- [batch2p](docs/batch2p.md) — single-session pipeline
+- [batch2p-multi](docs/batch2p_multi.md) — multi-session batch runner
+- [batch2p-gui](docs/batch2p_gui.md) — graphical interface

batch2p-0.1.0/batch2p/__init__.py

@@ -0,0 +1 @@
+"""batch2p – batch 2-photon preprocessing package."""

batch2p-0.1.0/batch2p/cli.py

@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""
+Batch 2-photon preprocessing – CLI entry point.
+
+Usage:
+    batch2p <data_suite3d.json> [--working-dir <dir>]
+
+The data JSON file must contain a "source_extraction" field specifying the
+algorithm (e.g. "suite3d"). Synchronization is handled generically and depends
+only on the original TIF and .b64 files.
+"""
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+# os.chdir(os.path.dirname(os.path.abspath("")))
+
+from totalsync_2p.sync import synchronize
+from batch2p.extractors import get_extractor
+
+
+class TeeStream:
+    """Write to both a stream and a file simultaneously."""
+    def __init__(self, stream, file):
+        self.stream = stream
+        self.file = file
+
+    def write(self, data):
+        self.stream.write(data)
+        self.file.write(data)
+
+    def flush(self):
+        self.stream.flush()
+        self.file.flush()
+
+    def fileno(self):
+        return self.stream.fileno()
+
+
+def collect_tifs(data: dict) -> list[Path]:
+    root = Path(data["root_path"]) if "root_path" in data else Path(".")
+    tifs = []
+    for item in data["data"]:
+        p = root / item
+        if p.suffix.lower() in (".tif", ".tiff"):
+            tifs.append(p)
+        elif p.is_dir():
+            tifs.extend(sorted(p.glob("*.tif")) + sorted(p.glob("*.tiff")))
+        else:
+            raise TypeError(f"Unexpected file type: {p}")
+    return tifs
+
+
+def split_tifs(tifs: list[Path], chunk_size: int, tmp_dir: Path,
+               block_size: int = 3, add_offset: bool = False) -> list[Path]:
+    from tifftrim.trim import split_3d_tiff_into_chunks
+    split = []
+    for tif in tifs:
+        chunks = split_3d_tiff_into_chunks(
+            tif, tmp_dir, chunk_size,
+            block_size=block_size,
+            add_offset=add_offset,
+        )
+        split.extend(chunks)
+    return split
+
+
+def _can_create_dir(p: Path) -> bool:
+    """Return True if p already exists as a directory or could be created."""
+    p = p.resolve()
+    candidate = p
+    while not candidate.exists():
+        parent = candidate.parent
+        if parent == candidate:
+            return False  # reached filesystem root with nothing existing
+        candidate = parent
+    return candidate.is_dir() and os.access(candidate, os.W_OK)
+
+
+def dry_run(args, data: dict) -> int:
+    """Check all inputs exist and all output dirs are creatable. Returns exit code."""
+    errors = []
+    ok_lines = []
+
+    def check_file(p: Path, label: str):
+        if p.exists() and p.is_file():
+            ok_lines.append(f"  [OK]     {label}: {p}")
+        else:
+            errors.append(f"  [MISSING] {label}: {p}")
+
+    def check_dir(p: Path, label: str):
+        if p.exists() and p.is_dir():
+            ok_lines.append(f"  [OK]     {label}: {p}")
+        elif _can_create_dir(p):
+            ok_lines.append(f"  [OK]     {label}: {p}  (will be created)")
+        else:
+            errors.append(f"  [MISSING] {label}: {p}  (cannot create)")
+
+    # ── Input files ───────────────────────────────────────────────────────────
+    print("Checking input files...")
+
+    params_file = Path(data["params_file"])
+    check_file(params_file, "params file")
+
+    root = Path(data["root_path"]) if "root_path" in data else Path(".")
+    for item in data["data"]:
+        p = root / item
+        if p.suffix.lower() in (".tif", ".tiff"):
+            check_file(p, "tif")
+        elif p.is_dir():
+            tifs = sorted(p.glob("*.tif")) + sorted(p.glob("*.tiff"))
+            if tifs:
+                for t in tifs:
+                    ok_lines.append(f"  [OK]     tif: {t}")
+            else:
+                errors.append(f"  [MISSING] tif dir (empty or missing): {p}")
+        else:
+            if p.exists():
+                errors.append(f"  [ERROR]  unexpected file type: {p}")
+            else:
+                errors.append(f"  [MISSING] tif: {p}")
+
+    if "behavior_data" in data:
+        for item in data["behavior_data"]:
+            p = root / item
+            check_file(p, "b64")
+        pinsheet_file = Path(data["pinsheet_file"])
+        if not pinsheet_file.is_absolute():
+            pinsheet_file = root / pinsheet_file
+        check_file(pinsheet_file, "pinsheet file")
+
+    # ── Output directories ────────────────────────────────────────────────────
+    print("Checking output directories...")
+
+    job_id = data.get("job_id", "")
+    check_dir(Path(data["job_root_dir"]), "job root dir")
+    results_root = Path(data.get("results_root_dir", str(Path(data["job_root_dir"]) / "results")))
+    check_dir(results_root, "results root dir")
+    check_dir(results_root / job_id, "results dir")
+
+    if "temp_dir" in data:
+        check_dir(Path(data["temp_dir"]), "temp/scratch dir")
+
+    working_dir_base = args.working_dir or (Path(data["working_dir"]) if "working_dir" in data else None)
+    if working_dir_base is not None:
+        check_dir(Path(working_dir_base), "working dir")
+
+    # ── Report ────────────────────────────────────────────────────────────────
+    for line in ok_lines:
+        print(line)
+    if errors:
+        print("\nERRORS:")
+        for line in errors:
+            print(line, file=sys.stderr)
+        print(f"\nDry run FAILED: {len(errors)} issue(s) found.", file=sys.stderr)
+        return 1
+
+    print(f"\nDry run OK: all files present and output directories are accessible.")
+    return 0
+
+
+def collect_b64s(data: dict) -> list[Path]:
+    root = Path(data["root_path"]) if "root_path" in data else Path(".")
+    b64s = []
+    for item in data["behavior_data"]:
+        p = root / item
+        if p.suffix.lower() != ".b64":
+            raise TypeError(f"Expected a .b64 file in behavior_data, got: {p}")
+        b64s.append(p)
+    return b64s
+
+
+def copy_files_to_working_dir(files: list[Path], dest_dir: Path) -> list[Path]:
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    copied = []
+    for f in files:
+        dest = dest_dir / f.name
+        print(f"  {f} -> {dest}")
+        shutil.copy2(f, dest)
+        copied.append(dest)
+    return copied
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch 2-photon preprocessing")
+    parser.add_argument("data_json", type=Path, help="Path to data JSON file")
+    parser.add_argument("--working-dir", type=Path, default=None,
+                        help="Local scratch directory. Input files are copied here; "
+                             "results are copied back to their original destinations on completion.")
+    parser.add_argument("--debug", action="store_true",
+                        help="Debug mode: skip cleanup of temp/working directories on error.")
+    parser.add_argument("--sync-only", action="store_true",
+                        help="Skip source extraction; assume results already exist and only run synchronization.")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Check that all input files exist and all output directories are "
+                             "creatable, then exit without running anything.")
+    args = parser.parse_args()
+    sync_only = args.sync_only
+
+    with open(args.data_json) as f:
+        data = json.load(f)
+
+    if args.dry_run:
+        sys.exit(dry_run(args, data))
+
+    algorithm = data.get("source_extraction", "suite3d")
+    extractor = get_extractor(algorithm, data)
+
+    job_id = data["job_id"]
+    original_job_root_dir = Path(data["job_root_dir"])
+    original_results_root_dir = Path(data.get("results_root_dir",
+                                               str(original_job_root_dir / "results")))
+    original_results_path = original_results_root_dir / job_id
+
+    fill_tsync_gaps = bool(data.get("fill_tsync_gaps", False))
+    ignore_barcode = bool(data.get("ignore_barcode", False))
+    block_size = int(data.get("block_size", 3))
+    working_dir_base = args.working_dir or (Path(data["working_dir"]) if "working_dir" in data else None)
+
+    if working_dir_base is not None:
+        working_dir_base.mkdir(parents=True, exist_ok=True)
+        working_dir = Path(tempfile.mkdtemp(prefix=f"batch2p_{job_id}_", dir=working_dir_base))
+    else:
+        working_dir = None
+
+    tifs = collect_tifs(data)
+    original_tifs = tifs
+    print("Input files:")
+    for t in tifs:
+        print(f"  {t}")
+
+    has_behavior = "behavior_data" in data
+    if has_behavior:
+        b64_files = collect_b64s(data)
+        if len(b64_files) != len(original_tifs):
+            raise ValueError(
+                f"behavior_data has {len(b64_files)} entries but data has "
+                f"{len(original_tifs)} tif files; counts must match."
+            )
+        pinsheet_file = Path(data["pinsheet_file"])
+        if not pinsheet_file.is_absolute():
+            root = Path(data["root_path"]) if "root_path" in data else Path(".")
+            pinsheet_file = root / pinsheet_file
+    else:
+        b64_files = []
+        pinsheet_file = None
+
+    if working_dir is not None:
+        job_root_dir = working_dir / original_job_root_dir.name
+        results_root_dir = working_dir / original_results_root_dir.name
+    else:
+        job_root_dir = original_job_root_dir
+        results_root_dir = original_results_root_dir
+
+    results_path = results_root_dir / job_id
+    results_path.mkdir(parents=True, exist_ok=True)
+
+    log_path = results_path / f"{job_id}.log"
+    log_file = open(log_path, "w", buffering=1)  # line-buffered
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+    sys.stdout = TeeStream(original_stdout, log_file)
+    sys.stderr = TeeStream(original_stderr, log_file)
+
+    tmp_dir = None
+    _exception_raised = False
+    try:
+        if sync_only:
+            if not original_results_path.exists():
+                raise FileNotFoundError(
+                    f"--sync_only: no existing results found at {original_results_path}"
+                )
+            if working_dir is not None:
+                print(f"\nSession temp directory: {working_dir}")
+                print(f"Copying existing results to working directory: {results_path} ...")
+                for item in original_results_path.iterdir():
+                    if item.suffix == ".log":
+                        continue
+                    dest = results_path / item.name
+                    if item.is_dir():
+                        shutil.copytree(str(item), str(dest))
+                    else:
+                        shutil.copy2(str(item), str(dest))
+                print("Done copying.")
+        else:
+            if working_dir is not None:
+                print(f"\nSession temp directory: {working_dir}")
+                print("Copying input files to working directory...")
+                tifs = copy_files_to_working_dir(tifs, working_dir / "input_tifs")
+                if has_behavior:
+                    b64_files = copy_files_to_working_dir(b64_files, working_dir / "input_b64s")
+                print("Done copying.")
+
+        # Save pre-split tif paths for behavioral sync (b64 files are per-session, not per-chunk)
+        tifs_for_sync = list(tifs)
+
+        if not sync_only:
+            chunk_size = int(data.get("tiff_trim_size", 0))
+            if chunk_size:
+                if working_dir is not None:
+                    tmp_dir = working_dir / "split_tifs"
+                    tmp_dir.mkdir(parents=True, exist_ok=True)
+                else:
+                    tmp_parent = Path(data["temp_dir"]) if "temp_dir" in data else None
+                    if tmp_parent is not None:
+                        tmp_parent.mkdir(parents=True, exist_ok=True)
+                    tmp_dir = Path(tempfile.mkdtemp(prefix="batch2p_", dir=tmp_parent))
+                print(f"\nSplitting TIFFs into chunks of {chunk_size} frames -> {tmp_dir}")
+                add_offset = bool(data.get("add_offset", False))
+                tifs = split_tifs(tifs, chunk_size, tmp_dir, block_size=block_size, add_offset=add_offset)
+                print("Split files:")
+                for t in tifs:
+                    print(f"  {t}")
+
+            # When a working directory is used, let the extractor know so it can place
+            # any algorithm-level scratch files (e.g. suite2p fast_disk) there.
+            if working_dir is not None:
+                data["temp_dir"] = str(working_dir)
+
+            # Save reproducibility files
+            extractor.save_reproducibility_info(results_path)
+
+            saved_data = dict(data)
+            saved_data["data"] = [str(t) for t in original_tifs]
+            saved_data.pop("root_path", None)
+            saved_data["results_root_dir"] = str(original_results_root_dir)
+            saved_data["job_root_dir"] = str(original_job_root_dir)
+            with open(results_path / "data_used.json", "w") as f:
+                json.dump(saved_data, f, indent=2)
+
+            # Run source extraction
+            extractor.run(tifs, job_root_dir, job_id, results_path)
+
+        if has_behavior:
+            print("\nRunning behavioral synchronization...")
+            behavior_sync_dir = results_root_dir / "behavior_sync"
+            behavior_sync_dir.mkdir(parents=True, exist_ok=True)
+            sync_results = []
+            for tif, b64 in zip(tifs_for_sync, b64_files):
+                print(f"  Synchronizing {tif.name} + {b64.name}")
+                stats = synchronize(str(tif), str(b64), str(behavior_sync_dir), str(pinsheet_file),
+                                    fill_gaps=fill_tsync_gaps, ignore_barcode=ignore_barcode)
+                sync_results.append(stats)
+            print("Behavioral synchronization done.")
+
+            print(f"\nCreating behavior-synced {algorithm} outputs...")
+            extractor.create_synced_outputs(
+                tif_files=tifs_for_sync,
+                sync_results=sync_results,
+                results_path=results_path,
+                behavior_sync_dir=behavior_sync_dir,
+                block_size=block_size,
+            )
+            print("Synced outputs done.")
+
+    except Exception:
+        _exception_raised = True
+        raise
+    finally:
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        log_file.flush()
+        log_file.close()
+
+        skip_cleanup = args.debug and _exception_raised
+
+        if tmp_dir is not None and tmp_dir.exists() and working_dir is None:
+            if skip_cleanup:
+                print(f"\n[debug] Keeping temporary directory on error: {tmp_dir}")
+            else:
+                shutil.rmtree(tmp_dir)
+                print(f"\nCleaned up temporary directory: {tmp_dir}")
+
+        if working_dir is not None and working_dir.exists():
+            if skip_cleanup:
+                print(f"\n[debug] Keeping session temp directory on error: {working_dir}")
+            else:
+                try:
+                    print(f"\nCopying results back to {original_results_path} ...")
+                    if original_results_path.exists():
+                        shutil.rmtree(original_results_path)
+                    original_results_root_dir.mkdir(parents=True, exist_ok=True)
+                    shutil.copytree(str(results_path), str(original_results_path))
+
+                    job_subdir = extractor.get_job_subdir(job_id)
+                    working_job_path = job_root_dir / job_subdir
+                    original_job_path = original_job_root_dir / job_subdir
+                    if working_job_path.exists():
+                        print(f"Copying job directory back to {original_job_path} ...")
+                        if original_job_path.exists():
+                            shutil.rmtree(original_job_path)
+                        if original_job_root_dir.exists() and not original_job_root_dir.is_dir():
+                            raise RuntimeError(
+                                f"Cannot create job root directory: {original_job_root_dir} "
+                                f"already exists as a non-directory file. "
+                                f"Remove or rename it and retry."
+                            )
+                        original_job_root_dir.mkdir(parents=True, exist_ok=True)
+                        shutil.copytree(str(working_job_path), str(original_job_path))
+
+                    if has_behavior:
+                        working_behavior_sync = results_root_dir / "behavior_sync"
+                        original_behavior_sync = original_results_root_dir / "behavior_sync"
+                        if working_behavior_sync.exists():
+                            print(f"Copying behavior_sync back to {original_behavior_sync} ...")
+                            if original_behavior_sync.exists():
+                                shutil.rmtree(original_behavior_sync)
+                            original_results_root_dir.mkdir(parents=True, exist_ok=True)
+                            shutil.copytree(str(working_behavior_sync), str(original_behavior_sync))
+
+                    print(f"Cleaning up session temp directory: {working_dir} ...")
+                    shutil.rmtree(working_dir)
+                    print("Done.")
+                except Exception as copy_err:
+                    if _exception_raised:
+                        print(f"\nWARNING: copy-back failed ({type(copy_err).__name__}: {copy_err}); "
+                              f"working directory preserved at: {working_dir}", file=sys.stderr)
+                    else:
+                        raise
+
+
+if __name__ == "__main__":
+    main()

batch2p-0.1.0/batch2p/compute_F_sub.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Compute baseline-subtracted neuropil-corrected fluorescence (F_sub.npy).
+
+Looks for F.npy and Fneu.npy in the current directory and writes F_sub.npy
+to the same directory.
+
+  F_sub = dcnv.preprocess(F - neucoeff * Fneu)
+
+Parameters are read from a params.json file supplied via --params-file.
+The JSON may use the same two-level structure as suite2p batch params:
+  - 'extraction:' section: neuropil_coefficient  (fallback: 'neucoeff', default 0.7)
+  - 'dcnv_preprocess' section: baseline, win_baseline, sig_baseline,
+                                prctile_baseline  (fallbacks from flat keys)
+  - flat keys: fs, batch_size, torch_device
+
+With --normalise, also computes dF/F from F_sub and writes dFF.npy:
+
+  dFF = (F_sub - F0) / F0
+
+where F0 is a rolling percentile baseline (percentile_filter). Options
+--dff-window-sec, --dff-percentile, and --dff-abs-floor control the
+computation.
+"""
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+def _detect_torch_device() -> str:
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return "cuda"
+    except ImportError:
+        pass
+    try:
+        import cupy
+        if cupy.cuda.runtime.getDeviceCount() > 0:
+            return "cuda"
+    except Exception:
+        pass
+    return "cpu"
+
+
+def compute_F_sub(work_dir: Path, settings: dict) -> np.ndarray:
+    import torch
+    from suite2p.extraction import dcnv
+
+    f_path = work_dir / "F.npy"
+    fneu_path = work_dir / "Fneu.npy"
+
+    if not f_path.exists():
+        raise FileNotFoundError(f"F.npy not found in {work_dir}")
+    if not fneu_path.exists():
+        raise FileNotFoundError(f"Fneu.npy not found in {work_dir}")
+
+    F = np.load(f_path)
+    Fneu = np.load(fneu_path)
+
+    extraction = settings.get('extraction:', {})
+    neucoeff = float(extraction.get('neuropil_coefficient', settings.get('neucoeff', 0.7)))
+    print(f"neuropil_coefficient: {neucoeff}")
+    Fc = F - neucoeff * Fneu
+
+    dcnv_section = settings.get('dcnv_preprocess', {})
+    def _p(key, default):
+        return dcnv_section.get(key, settings.get(key, default))
+
+    torch_device = settings.get('torch_device') or _detect_torch_device()
+    device = torch.device(torch_device)
+    print(f"torch_device: {torch_device}")
+
+    F_sub = dcnv.preprocess(
+        F=Fc,
+        baseline=_p('baseline', 'maximin'),
+        win_baseline=float(_p('win_baseline', 60.0)),
+        sig_baseline=float(_p('sig_baseline', 10.0)),
+        fs=float(settings.get('fs', 10.0)),
+        prctile_baseline=float(_p('prctile_baseline', 8.0)),
+        batch_size=int(settings.get('batch_size', 200)),
+        device=device,
+    )
+
+    out_path = work_dir / "F_sub.npy"
+    np.save(out_path, F_sub)
+    print(f"Saved {out_path}  shape={F_sub.shape}")
+    return F_sub
+
+
+def compute_dff(f_sub, fs=29.96, window_sec=300, percentile=8, abs_floor=10):
+    from scipy.ndimage import percentile_filter
+    window_frames = int(window_sec * fs)
+    n_cells, n_frames = f_sub.shape
+    dff = np.empty_like(f_sub)
+    f0_clamped = np.empty_like(f_sub)
+    for i in range(n_cells):
+        f0 = percentile_filter(f_sub[i], percentile, size=window_frames, mode='nearest')
+        f0c = np.maximum(f0, abs_floor)
+        dff[i] = (f_sub[i] - f0c) / f0c
+        f0_clamped[i] = f0c
+    return dff, f0_clamped
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--params-file', required=True, type=Path,
+                        help='Path to params.json')
+    parser.add_argument('--normalise', '--normalize', action='store_true',
+                        help='Also compute dF/F from F_sub and save as dFF.npy.')
+    parser.add_argument('--dff-window-sec', type=float, default=300,
+                        help='Rolling baseline window in seconds for dF/F (default: 300).')
+    parser.add_argument('--dff-percentile', type=float, default=8,
+                        help='Percentile used for the F0 baseline estimate (default: 8).')
+    parser.add_argument('--dff-abs-floor', type=float, default=10,
+                        help='Absolute fluorescence floor clamped onto F0 (default: 10).')
+    args = parser.parse_args()
+
+    params_file = args.params_file
+    if not params_file.exists():
+        parser.error(f"params file not found: {params_file}")
+
+    with open(params_file) as f:
+        settings = json.load(f)
+    settings.pop('comments', None)
+
+    work_dir = Path.cwd()
+    print(f"Working directory: {work_dir}")
+    F_sub = compute_F_sub(work_dir, settings)
+
+    if args.normalise:
+        fs = float(settings.get('fs', 10.0))
+        print(f"Computing dF/F  (window={args.dff_window_sec}s, "
+              f"percentile={args.dff_percentile}, abs_floor={args.dff_abs_floor}, fs={fs})")
+        dff, _ = compute_dff(F_sub, fs=fs,
+                             window_sec=args.dff_window_sec,
+                             percentile=args.dff_percentile,
+                             abs_floor=args.dff_abs_floor)
+        dff_path = work_dir / "dFF.npy"
+        np.save(dff_path, dff)
+        print(f"Saved {dff_path}  shape={dff.shape}")
+
+
+if __name__ == '__main__':
+    main()