microstructure-tpw 0.3.0__py3-none-any.whl

odas_tpw/pyturb/bin.py

@@ -0,0 +1,113 @@
+"""pyturb-cli bin: depth-bin profile results."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+import numpy as np
+import xarray as xr
+
+logger = logging.getLogger(__name__)
+
+
+def run_bin(args: argparse.Namespace) -> None:
+    """Execute the bin subcommand."""
+    output_path = Path(args.output)
+
+    # Collect input files
+    paths: list[Path] = []
+    for pattern in args.files:
+        p = Path(pattern)
+        if p.is_file():
+            paths.append(p)
+        else:
+            paths.extend(sorted(Path(".").glob(pattern)))
+
+    if not paths:
+        logger.error("No input files found")
+        return
+
+    var_names = [v.strip() for v in args.vars.split(",") if v.strip()]
+
+    from odas_tpw.rsi.binning import bin_by_depth
+    from odas_tpw.rsi.combine import combine_profiles
+
+    binned_list: list[xr.Dataset] = []
+    metadata_list: list[dict] = []
+
+    # pyturb-cli bins dissipation with the GEOMETRIC (log-space) mean for
+    # Jesse-parity. NOTE (audit 2026-07-01): this is the per-bin MEDIAN of a
+    # lognormal, systematically LOWER than the ARITHMETIC-mean binned products
+    # from the perturb/rsi pipelines on the same data (by exp(-sigma_ln^2/2):
+    # ~0.61x at sigma_ln=1.0, ~0.32x at 1.5). Do not mix these two products.
+    log_mean_vars = {"eps_1", "eps_2", "eps_final", "epsilon", "chi", "chi_final", "epsi_final"}
+    logger.info(
+        "pyturb bin: dissipation (%s) uses the GEOMETRIC mean (median of a "
+        "lognormal), NOT the arithmetic mean used by the perturb/rsi products",
+        ", ".join(sorted(log_mean_vars)),
+    )
+
+    for filepath in sorted(paths):
+        try:
+            ds = xr.open_dataset(filepath)
+        except Exception as e:
+            logger.error(f"{filepath.name}: {e}")
+            continue
+
+        # Get pressure
+        if "pressure" in ds:
+            pres = ds["pressure"].values
+        elif "P_mean" in ds:
+            pres = ds["P_mean"].values
+        else:
+            logger.warning(f"{filepath.name}: no pressure variable, skipping")
+            ds.close()
+            continue
+
+        # Convert pressure to depth if not using --pressure mode
+        if not args.pressure:
+            try:
+                import gsw
+
+                depth = -gsw.z_from_p(pres, args.lat)
+            except ImportError:
+                logger.warning("gsw not available, binning by pressure instead")
+                depth = pres
+        else:
+            depth = pres
+
+        # Collect variables
+        values: dict[str, np.ndarray] = {}
+        for vname in var_names:
+            if vname in ds:
+                values[vname] = ds[vname].values
+
+        if not values:
+            logger.warning(f"{filepath.name}: no matching variables, skipping")
+            ds.close()
+            continue
+
+        binned = bin_by_depth(
+            depth,
+            values,
+            bin_size=args.bin_width,
+            pres_range=(args.dmin, args.dmax),
+            log_mean_vars=log_mean_vars & set(var_names),
+        )
+        binned_list.append(binned)
+        metadata_list.append({"source": filepath.name})
+        ds.close()
+
+    if not binned_list:
+        logger.error("No profiles binned")
+        return
+
+    combined = combine_profiles(binned_list, profile_metadata=metadata_list)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    combined.to_netcdf(output_path)
+
+    n_prof = combined.sizes.get("profile", 0)
+    n_bins = combined.sizes.get("depth_bin", 0)
+    print(f"Binned {n_prof} profiles x {n_bins} depth bins -> {output_path.name}")

odas_tpw/pyturb/cli.py

@@ -0,0 +1,175 @@
+"""pyturb-cli: Jesse-compatible CLI for VMP turbulence processing.
+
+Provides four subcommands matching Jesse's pyturb interface:
+  p2nc   — convert .p files to NetCDF
+  merge  — merge multiple NetCDF files
+  eps    — compute epsilon (and gradT spectra)
+  bin    — depth-bin profile results
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+logger = logging.getLogger("pyturb")
+
+
+def _add_p2nc(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("p2nc", help="Convert .p files to NetCDF")
+    p.add_argument("files", nargs="+", help=".p files or glob patterns")
+    p.add_argument("-o", "--output", default=".", help="Output directory (default: .)")
+    p.add_argument("--compress", action="store_true", default=True, dest="compress")
+    p.add_argument("--no-compress", action="store_false", dest="compress")
+    p.add_argument("--compression-level", type=int, default=4, help="zlib level 1-9 (default: 4)")
+    p.add_argument("-n", "--n-workers", type=int, default=1, help="Parallel workers (default: 1)")
+    p.add_argument("--min-file-size", type=int, default=100000, help="Skip files < N bytes")
+    p.add_argument("-w", "--overwrite", action="store_true", default=False)
+    p.add_argument("-W", "--no-overwrite", action="store_false", dest="overwrite")
+    p.set_defaults(func=_run_p2nc)
+
+
+def _add_merge(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("merge", help="Merge NetCDF files along time")
+    p.add_argument("files", nargs="+", help=".nc files")
+    p.add_argument("-o", "--output", required=True, help="Output file (required)")
+    p.add_argument("--dry-run", action="store_true", help="Print summary without writing")
+    p.add_argument("-w", "--overwrite", action="store_true", default=False)
+    p.add_argument("-W", "--no-overwrite", action="store_false", dest="overwrite")
+    p.set_defaults(func=_run_merge)
+
+
+def _add_eps(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("eps", help="Compute epsilon and gradT spectra")
+    p.add_argument("files", nargs="+", help=".p or .nc files")
+    p.add_argument("-o", "--output", required=True, help="Output directory (required)")
+    p.add_argument("-d", "--diss-len", type=float, default=4.0, help="Dissipation window [s]")
+    p.add_argument("-f", "--fft-len", type=float, default=1.0, help="FFT segment [s]")
+    p.add_argument("-s", "--min-speed", type=float, default=0.2, help="Min profiling speed [m/s]")
+    p.add_argument(
+        "--pressure-smoothing", type=float, default=0.25, help="Pressure smoothing [s]"
+    )
+    p.add_argument("-t", "--temperature", default="JAC_T", help="Temperature variable name")
+    p.add_argument("--speed", default="W", help="Speed variable name")
+    p.add_argument(
+        "--direction", choices=["down", "up", "both"], default="down", help="Profile direction"
+    )
+    p.add_argument("--min-profile-pressure", type=float, default=0.0, help="Min pressure [dbar]")
+    p.add_argument("--peaks-height", type=float, default=25.0, help="Peak height [dbar]")
+    p.add_argument("--peaks-distance", type=int, default=200, help="Peak distance [samples]")
+    p.add_argument("--peaks-prominence", type=float, default=25.0, help="Peak prominence [dbar]")
+    p.add_argument("--despike-passes", type=int, default=6, help="Despike passes")
+    p.add_argument("-a", "--aux", help="Auxiliary CTD NetCDF file")
+    p.add_argument("--aux-lat", default="lat", help="Auxiliary latitude variable")
+    p.add_argument("--aux-lon", default="lon", help="Auxiliary longitude variable")
+    p.add_argument("--aux-temp", default="temperature", help="Auxiliary temperature variable")
+    p.add_argument("--aux-sal", default="salinity", help="Auxiliary salinity variable")
+    p.add_argument("--aux-dens", default="density", help="Auxiliary density variable")
+    p.add_argument("--salinity", type=float, default=35.0, help="Salinity [PSU] (default: 35)")
+    p.add_argument("-n", "--n-workers", type=int, default=1, help="Parallel workers")
+    p.add_argument("-w", "--overwrite", action="store_true", default=False)
+    p.add_argument("-W", "--no-overwrite", action="store_false", dest="overwrite")
+    p.add_argument("--goodman", action="store_true", default=False, dest="goodman",
+                   help="Enable Goodman coherent noise removal (off by default to match pyturb)")
+    p.add_argument("--no-goodman", action="store_false", dest="goodman",
+                   help="Disable Goodman cleaning (default)")
+    p.add_argument("--aoa", type=float, default=None, help="Angle of attack (not implemented)")
+    p.add_argument(
+        "--pitch-correction", action="store_true", default=False, help="(not implemented)"
+    )
+    p.set_defaults(func=_run_eps)
+
+
+def _add_bin(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser("bin", help="Depth-bin profile results")
+    p.add_argument("files", nargs="+", help="Profile .nc files (from eps)")
+    p.add_argument("-o", "--output", default="binned_profiles.nc", help="Output file")
+    p.add_argument("-b", "--bin-width", type=float, default=2.0, help="Bin width [m]")
+    p.add_argument("--dmin", type=float, default=0.0, help="Min depth [m]")
+    p.add_argument("--dmax", type=float, default=1000.0, help="Max depth [m]")
+    p.add_argument("--lat", type=float, default=45.0, help="Latitude for P-to-depth")
+    p.add_argument("-p", "--pressure", action="store_true", help="Bin by pressure instead of depth")
+    p.add_argument(
+        "-v",
+        "--vars",
+        default="eps_1,eps_2,W,temperature,salinity,density,nu,lat,lon",
+        help="Variables to bin (comma-separated)",
+    )
+    p.add_argument("-n", "--n-workers", type=int, default=1, help="Parallel workers")
+    p.set_defaults(func=_run_bin)
+
+
+# ---------------------------------------------------------------------------
+# Dispatch wrappers
+# ---------------------------------------------------------------------------
+
+
+def _run_p2nc(args: argparse.Namespace) -> None:
+    from odas_tpw.pyturb.p2nc import run_p2nc
+
+    run_p2nc(args)
+
+
+def _run_merge(args: argparse.Namespace) -> None:
+    from odas_tpw.pyturb.merge import run_merge
+
+    run_merge(args)
+
+
+def _run_eps(args: argparse.Namespace) -> None:
+    if args.aoa is not None:
+        logger.warning("--aoa is accepted but not implemented")
+    if args.pitch_correction:
+        logger.warning("--pitch-correction is accepted but not implemented")
+
+    from odas_tpw.pyturb.eps import run_eps
+
+    run_eps(args)
+
+
+def _run_bin(args: argparse.Namespace) -> None:
+    from odas_tpw.pyturb.bin import run_bin
+
+    run_bin(args)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="pyturb-cli",
+        description="Jesse-compatible VMP processing CLI backed by odas_tpw",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="count", default=0, help="Increase verbosity (-v, -vv)"
+    )
+
+    sub = parser.add_subparsers(dest="command")
+    _add_p2nc(sub)
+    _add_merge(sub)
+    _add_eps(sub)
+    _add_bin(sub)
+
+    args = parser.parse_args(argv)
+
+    # Configure logging
+    level = logging.WARNING
+    if args.verbose >= 2:
+        level = logging.DEBUG
+    elif args.verbose >= 1:
+        level = logging.INFO
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

odas_tpw/pyturb/eps.py

@@ -0,0 +1,353 @@
+"""pyturb-cli eps: compute epsilon and temperature gradient spectra."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+
+from odas_tpw.pyturb._compat import (
+    check_overwrite,
+    load_auxiliary,
+    rename_eps_dataset,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _process_one_file(
+    filepath: Path,
+    output_dir: Path,
+    *,
+    fft_len_sec: float,
+    diss_len_sec: float,
+    direction: str,
+    min_speed: float,
+    min_profile_pressure: float,
+    peaks_height: float,
+    peaks_distance: int,
+    peaks_prominence: float,
+    despike_passes: int,
+    salinity: float,
+    overwrite: bool,
+    goodman: bool = False,
+    aux_path: str | None = None,
+    aux_kwargs: dict | None = None,
+    pressure_smoothing: float = 0.25,
+) -> list[Path]:
+    """Process a single file: detect profiles, compute epsilon + gradT spectra."""
+    from odas_tpw.pyturb._compat import compute_window_parameters
+    from odas_tpw.pyturb._profind import find_profiles_peaks
+    from odas_tpw.rsi.adapter import nc_to_l1data, pfile_to_l1data
+    from odas_tpw.rsi.p_file import PFile
+    from odas_tpw.scor160.io import L2Params, L3Params
+
+    def _window_for_fs(fs: float):
+        """Convert the requested FFT/diss DURATIONS to sample counts at this
+        file's actual fs (NOT a fixed 512 Hz), so window durations are correct
+        for non-512-Hz instruments."""
+        n_fft, n_diss, _fft_ovlp, diss_ovlp = compute_window_parameters(
+            fft_len_sec, diss_len_sec, fs
+        )
+        return n_fft, n_diss, diss_ovlp
+
+    suffix = filepath.suffix.lower()
+    stem = filepath.stem
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load auxiliary data if provided
+    aux_data = None
+    if aux_path:
+        aux_data = load_auxiliary(aux_path, **(aux_kwargs or {}))
+
+    l2_params = L2Params(
+        HP_cut=0.25,
+        despike_sh=np.array([8.0, 0.5, 0.04]),
+        despike_A=np.array([np.inf, 0.5, 0.04]),
+        profile_min_W=min_speed,
+        profile_min_P=min_profile_pressure,
+        profile_min_duration=10.0,
+        speed_tau=1.5,
+    )
+
+    # Window sample counts are (re)computed per file from its own fs_fast in
+    # each branch below; seed with the 512 Hz values so L3Params is valid.
+    _n_fft0, _n_diss0, _ovlp0 = _window_for_fs(512.0)
+    l3_params = L3Params(
+        fft_length=_n_fft0,
+        diss_length=_n_diss0,
+        overlap=_ovlp0,
+        HP_cut=0.25,
+        fs_fast=512.0,  # overwritten per-file below
+        goodman=goodman,
+    )
+
+    output_paths: list[Path] = []
+
+    if suffix == ".p":
+        pf = PFile(filepath)
+        fs_fast = pf.fs_fast
+        fs_slow = pf.fs_slow
+        l3_params.fs_fast = fs_fast
+        l3_params.fft_length, l3_params.diss_length, l3_params.overlap = (
+            _window_for_fs(fs_fast)
+        )
+
+        # Detect profiles using peak-finding
+        P_slow = pf.channels.get("P_dP", pf.channels.get("P"))
+        if P_slow is None:
+            logger.error(f"{filepath.name}: no pressure channel")
+            return []
+
+        profiles = find_profiles_peaks(
+            P_slow,
+            fs_slow,
+            direction=direction,
+            min_pressure=min_profile_pressure,
+            peaks_height=peaks_height,
+            peaks_distance=peaks_distance,
+            peaks_prominence=peaks_prominence,
+            min_speed=min_speed,
+            smoothing_tau=pressure_smoothing,
+        )
+
+        if not profiles:
+            logger.warning(f"{filepath.name}: no profiles detected")
+            return []
+
+        for pi, (s_slow, e_slow) in enumerate(profiles):
+            out_path = output_dir / f"{stem}_p{pi:04d}.nc"
+            if not check_overwrite(out_path, overwrite):
+                logger.info(f"Skipping {out_path.name}: exists")
+                continue
+
+            # Build L1Data for this profile
+            l1 = pfile_to_l1data(pf, profile_slice=(s_slow, e_slow), direction=direction)
+            ds = _process_profile(l1, l2_params, l3_params, salinity, aux_data)
+            if ds is not None:
+                ds.attrs["source_file"] = filepath.name
+                ds.attrs["profile_index"] = pi
+                ds.to_netcdf(out_path)
+                output_paths.append(out_path)
+                logger.info(f"{out_path.name}: {ds.sizes.get('time', 0)} estimates")
+
+    elif suffix == ".nc":
+        # Load from NetCDF (may be full-record or single-profile)
+        l1 = nc_to_l1data(filepath)
+        fs_fast = l1.fs_fast
+        fs_slow = l1.fs_slow
+        l3_params.fs_fast = fs_fast
+        l3_params.fft_length, l3_params.diss_length, l3_params.overlap = (
+            _window_for_fs(fs_fast)
+        )
+
+        if l1.pres.size == 0:
+            logger.error(f"{filepath.name}: no pressure data")
+            return []
+
+        # If pressure range suggests a single profile, process directly
+        pres_range = np.nanmax(l1.pres) - np.nanmin(l1.pres)
+        if pres_range < peaks_height * 2:
+            # Single profile — process entire file
+            out_path = output_dir / f"{stem}_p0000.nc"
+            if not check_overwrite(out_path, overwrite):
+                return []
+            ds = _process_profile(l1, l2_params, l3_params, salinity, aux_data)
+            if ds is not None:
+                ds.attrs["source_file"] = filepath.name
+                ds.attrs["profile_index"] = 0
+                ds.to_netcdf(out_path)
+                output_paths.append(out_path)
+        else:
+            # Multiple profiles — use peak-finding on slow-rate pressure
+            if l1.pres_slow.size > 0:
+                P_for_peaks = l1.pres_slow
+                fs_peaks = fs_slow if fs_slow > 0 else fs_fast / 8
+            else:
+                P_for_peaks = l1.pres
+                fs_peaks = fs_fast
+
+            profiles = find_profiles_peaks(
+                P_for_peaks,
+                fs_peaks,
+                direction=direction,
+                min_pressure=min_profile_pressure,
+                peaks_height=peaks_height,
+                peaks_distance=peaks_distance,
+                peaks_prominence=peaks_prominence,
+                min_speed=min_speed,
+                smoothing_tau=pressure_smoothing,
+            )
+            if not profiles:
+                logger.warning(f"{filepath.name}: no profiles detected")
+                return []
+
+            ratio = round(fs_fast / fs_peaks) if fs_peaks < fs_fast else 1
+            for pi, (s_slow, e_slow) in enumerate(profiles):
+                out_path = output_dir / f"{stem}_p{pi:04d}.nc"
+                if not check_overwrite(out_path, overwrite):
+                    continue
+
+                # Slice L1Data
+                s_fast = s_slow * ratio
+                e_fast = min((e_slow + 1) * ratio, l1.n_time)
+
+                from odas_tpw.scor160.io import L1Data
+
+                l1_prof = L1Data(
+                    time=l1.time[s_fast:e_fast],
+                    pres=l1.pres[s_fast:e_fast],
+                    shear=l1.shear[:, s_fast:e_fast] if l1.shear.size > 0 else l1.shear,
+                    vib=l1.vib[:, s_fast:e_fast] if l1.vib.size > 0 else l1.vib,
+                    vib_type=l1.vib_type,
+                    fs_fast=l1.fs_fast,
+                    f_AA=l1.f_AA,
+                    vehicle=l1.vehicle,
+                    profile_dir=direction,
+                    time_reference_year=l1.time_reference_year,
+                    pspd_rel=l1.pspd_rel[s_fast:e_fast] if l1.pspd_rel.size > 0 else l1.pspd_rel,
+                    temp=l1.temp[s_fast:e_fast] if l1.temp.size >= e_fast else l1.temp,
+                    temp_fast=(
+                        l1.temp_fast[:, s_fast:e_fast]
+                        if l1.temp_fast.ndim == 2 and l1.temp_fast.shape[1] >= e_fast
+                        else l1.temp_fast
+                    ),
+                    diff_gains=l1.diff_gains,
+                )
+
+                ds = _process_profile(l1_prof, l2_params, l3_params, salinity, aux_data)
+                if ds is not None:
+                    ds.attrs["source_file"] = filepath.name
+                    ds.attrs["profile_index"] = pi
+                    ds.to_netcdf(out_path)
+                    output_paths.append(out_path)
+                    logger.info(f"{out_path.name}: {ds.sizes.get('time', 0)} estimates")
+    else:
+        logger.error(f"{filepath.name}: unsupported format {suffix}")
+
+    return output_paths
+
+
+def _process_profile(l1, l2_params, l3_params, salinity, aux_data):
+    """Run the shear + chi processing chain on a single profile L1Data."""
+    from odas_tpw.chi.l2_chi import process_l2_chi
+    from odas_tpw.chi.l3_chi import process_l3_chi
+    from odas_tpw.scor160.l2 import process_l2
+    from odas_tpw.scor160.l3 import process_l3
+    from odas_tpw.scor160.l4 import process_l4
+
+    try:
+        l2 = process_l2(l1, l2_params)
+        l3 = process_l3(l2, l1, l3_params)
+        l4 = process_l4(l3, temp=l3.temp, f_AA=l1.f_AA)
+    except Exception as e:
+        logger.error(f"Shear processing failed: {e}")
+        return None
+
+    if l4.n_spectra == 0:
+        return None
+
+    # Chi chain (temperature gradient spectra)
+    l3_chi = None
+    if l1.has_temp_fast:
+        try:
+            l2_chi = process_l2_chi(l1, l2)
+            l3_chi = process_l3_chi(l2_chi, l3_params, salinity=salinity)
+        except Exception as e:
+            logger.warning(f"Chi processing failed (continuing without gradT): {e}")
+
+    return rename_eps_dataset(
+        l4,
+        l3,
+        l3_chi,
+        aux_data=aux_data,
+        fs_fast=l1.fs_fast,
+        salinity=salinity,
+    )
+
+
+def run_eps(args: argparse.Namespace) -> None:
+    """Execute the eps subcommand."""
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Collect input files
+    paths: list[Path] = []
+    for pattern in args.files:
+        p = Path(pattern)
+        if p.is_file():
+            paths.append(p)
+        else:
+            paths.extend(sorted(Path(".").glob(pattern)))
+
+    if not paths:
+        logger.error("No input files found")
+        return
+
+    # Warn about accepted-but-unimplemented flags rather than silently ignoring
+    # them (audit 2026-07-01): --despike-passes never reaches despike() (which
+    # runs the scor160 default of 10 passes), and --temperature/--speed are read
+    # nowhere.
+    if getattr(args, "despike_passes", None) not in (None, 10):
+        logger.warning(
+            "--despike-passes=%s is not implemented; despike runs the scor160 "
+            "default (10 passes)", args.despike_passes,
+        )
+    if getattr(args, "temperature", None) is not None:
+        logger.warning("-t/--temperature is not implemented and is ignored")
+    if getattr(args, "speed", None) is not None:
+        logger.warning("--speed is not implemented and is ignored")
+
+    # FFT/diss durations (seconds) are converted to sample counts PER FILE using
+    # that file's own fs_fast inside _process_one_file, so window durations are
+    # correct for non-512-Hz instruments.
+    common_kwargs = dict(
+        fft_len_sec=args.fft_len,
+        diss_len_sec=args.diss_len,
+        goodman=args.goodman,
+        direction=args.direction,
+        min_speed=args.min_speed,
+        min_profile_pressure=args.min_profile_pressure,
+        peaks_height=args.peaks_height,
+        peaks_distance=args.peaks_distance,
+        peaks_prominence=args.peaks_prominence,
+        despike_passes=args.despike_passes,
+        salinity=args.salinity,
+        overwrite=args.overwrite,
+        pressure_smoothing=args.pressure_smoothing,
+    )
+
+    if args.aux:
+        common_kwargs["aux_path"] = args.aux
+        common_kwargs["aux_kwargs"] = {
+            "lat_var": args.aux_lat,
+            "lon_var": args.aux_lon,
+            "temp_var": args.aux_temp,
+            "sal_var": args.aux_sal,
+            "dens_var": args.aux_dens,
+        }
+
+    if args.n_workers <= 1:
+        for filepath in paths:
+            try:
+                out_paths = _process_one_file(filepath, output_dir, **common_kwargs)
+                for op in out_paths:
+                    print(f"  {op.name}")
+            except Exception as e:
+                logger.error(f"{filepath.name}: {e}")
+    else:
+        with ProcessPoolExecutor(max_workers=args.n_workers) as pool:
+            futures = {
+                pool.submit(_process_one_file, fp, output_dir, **common_kwargs): fp for fp in paths
+            }
+            for future in as_completed(futures):
+                fp = futures[future]
+                try:
+                    out_paths = future.result()
+                    for op in out_paths:
+                        print(f"  {op.name}")
+                except Exception as e:
+                    logger.error(f"{fp.name}: {e}")