scripts/run_picker_to_jsonl.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Memory-safe phase picking script for large HDF5 continuous waveform datasets.
Supports Mac/MPS, CUDA (single or multi-GPU), and CPU, with optional multi-process
DataLoader for parallel waveform prefetching.

Key design points:
  1. Resume skipping is pushed into HDF5WaveformDataset(skip_jsonl=...) so already
     processed samples are filtered from the metadata index before __getitem__ reads
     waveform arrays from HDF5.
  2. Segment raw data arrays are freed immediately after fill_segments_to_array to
     avoid unbounded RSS growth on day-long waveforms (~100 MB/sample).
  3. Uses torch.inference_mode() and explicit deletion of large temporary tensors.
  4. MPS: torch.mps.empty_cache() called every sample; model reloaded periodically
     (--reload_model_interval) to reset TorchScript allocator state.
  5. CUDA: non_blocking transfers, cuda.empty_cache every N samples; model reload
     disabled by default (not needed for CUDA allocator).
  6. Multi-process DataLoader: uses 'spawn' context on Linux to avoid h5py + fork
     deadlocks; each worker opens its own HDF5 handles lazily.

Recommended — Mac/MPS (restart loop to avoid MPS allocator accumulation):
  # Each run processes --max_samples new samples then exits with code 75.
  # The OS reclaims Metal + HDF5 allocator state on exit. --resume picks up
  # where the previous run left off. When all samples are done the script
  # exits with code 0 and the loop terminates naturally.
  while true; do
    python run_picker_to_jsonl.py \
      --h5_input 'data/hdf5/continuous_waveform_usa_*.h5' \
      --output_jsonl data/picks/output.jsonl \
      --picker_model pickers/pnsn.v1.jit \
      --polar_model pickers/polar.onnx \
      --device mps --max_samples 200
    [ $? -ne 75 ] && break
  done

Recommended — CUDA with multi-process prefetch:
  python run_picker_to_jsonl_mps_safe.py \
    --h5_input 'data/hdf5/continuous_waveform_usa_*.h5' \
    --output_jsonl data/picks/output.jsonl \
    --picker_model pickers/pnsn.v1.jit \
    --polar_model pickers/polar.onnx \
    --device cuda \
    --batch_size 4 \
    --num_workers 4 \
    --prefetch_factor 2 \
    --multiprocessing_context spawn
"""

import argparse
import datetime
import gc
import json
import platform
import signal
import sys
import time
import os
import heapq
from bisect import bisect_left
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

# Disable HDF5 POSIX file locking before h5py is imported.
# h5py calls H5open() (which reads HDF5_USE_FILE_LOCKING) the moment the
# module is imported.  Without this, h5py.File() can block indefinitely
# waiting to acquire a POSIX fcntl lock held by Spotlight, Time Machine,
# a crashed previous run, or an NFS server — with no timeout.
# Setting it here (read-only access) is safe; allow user override via env.
os.environ.setdefault("HDF5_USE_FILE_LOCKING", "FALSE")

import numpy as np
import torch
from torch.utils.data import DataLoader

try:
    import onnxruntime as ort
except Exception:
    ort = None

# Prefer the revised resume-aware loader. Keep a fallback name for compatibility.

from utils.hdf5_waveform_dataset import (
    HDF5WaveformDataset,
    waveform_collate_fn,
    hdf5_worker_init_fn,
)

# orjson is 3-10× faster than stdlib json for serialising Python dicts.
# Fall back gracefully if it is not installed.
try:
    import orjson as _orjson

    def _json_dumps(obj):
        return _orjson.dumps(obj).decode("utf-8")

except ImportError:
    _orjson = None

    def _json_dumps(obj):
        return json.dumps(obj, ensure_ascii=False)


PHASE_ID_TO_NAME = {
    0: "Pg",
    1: "Sg",
    2: "Pn",
    3: "Sn",
    4: "P",
    5: "S",
}


def format_seconds(seconds):
    seconds = float(seconds)
    if seconds < 60:
        return f"{seconds:.1f}s"
    if seconds < 3600:
        return f"{seconds / 60:.1f}min"
    return f"{seconds / 3600:.2f}h"


def format_rate(num, seconds, suffix="/s"):
    seconds = float(seconds)
    if seconds <= 0:
        return "inf" + suffix
    return f"{float(num) / seconds:.2f}{suffix}"


def safe_shape_text(x):
    try:
        if torch.is_tensor(x):
            return "x".join(str(v) for v in tuple(x.shape))
        if hasattr(x, "shape"):
            return "x".join(str(v) for v in tuple(x.shape))
    except Exception:
        pass
    return "?"


def select_torch_device(device_name="auto"):
    device_name = str(device_name).lower()

    if device_name == "auto":
        if torch.cuda.is_available():
            return torch.device("cuda"), "cuda"
        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
            return torch.device("mps"), "mps"
        return torch.device("cpu"), "cpu"

    if device_name == "cuda":
        if torch.cuda.is_available():
            return torch.device("cuda"), "cuda"
        print("[WARN] CUDA requested but not available. Fallback to CPU.")
        return torch.device("cpu"), "cpu"

    if device_name == "mps":
        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
            return torch.device("mps"), "mps"
        print("[WARN] MPS requested but not available. Fallback to CPU.")
        return torch.device("cpu"), "cpu"

    return torch.device("cpu"), "cpu"


def sync_device(device_type):
    if device_type == "cuda":
        torch.cuda.synchronize()
    elif device_type == "mps":
        try:
            torch.mps.synchronize()
        except Exception:
            pass


def empty_device_cache(device_type):
    if device_type == "cuda":
        torch.cuda.empty_cache()
    elif device_type == "mps":
        try:
            torch.mps.empty_cache()
        except Exception:
            pass


def force_device_cleanup(device_type, do_gc=True):
    """Conservative cleanup for CUDA/MPS/CPU."""
    sync_device(device_type)
    if do_gc:
        gc.collect()
    empty_device_cache(device_type)


# ── Per-sample timeout (SIGALRM, Unix/macOS only) ───────────────────────────
# On MPS, torch.mps.synchronize() and torch.mps.empty_cache() can hang
# indefinitely if the Metal command queue enters a bad state.  A SIGALRM
# watchdog lets us escape the hang, write an error record, and continue.
# SIGALRM is only available on the main thread on Unix; on Windows it is
# silently disabled.

_SIGALRM_AVAILABLE = hasattr(signal, "SIGALRM")


class _SampleTimeout(Exception):
    """Raised by SIGALRM when a single sample exceeds sample_timeout_sec."""


def _sample_timeout_handler(signum, frame):
    raise _SampleTimeout("sample timed out (Metal / ONNX hang?)")


class _SampleTimer:
    """Context manager that arms/disarms SIGALRM around one sample.

    Usage::

        with _SampleTimer(timeout_sec):
            ... process one sample ...

    On timeout, _SampleTimeout is raised in the SIGALRM handler, which
    propagates through the with-block.  The caller should catch it, write an
    error record, and continue to the next sample.

    If SIGALRM is not available (Windows) or timeout_sec <= 0, this is a no-op.
    """

    __slots__ = ("_timeout",)

    def __init__(self, timeout_sec: int):
        self._timeout = timeout_sec if _SIGALRM_AVAILABLE and timeout_sec > 0 else 0

    def __enter__(self):
        if self._timeout > 0:
            signal.signal(signal.SIGALRM, _sample_timeout_handler)
            signal.alarm(self._timeout)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self._timeout > 0:
            signal.alarm(0)          # cancel any pending alarm
            signal.signal(signal.SIGALRM, signal.SIG_DFL)
        return False                 # do not suppress exceptions


def get_process_rss_mb():
    """Return current process RSS in MB if psutil is available."""
    try:
        import psutil
        return psutil.Process(os.getpid()).memory_info().rss / (1024 ** 2)
    except Exception:
        return None


def get_device_memory_text(device_type):
    """Return a short memory stats string for progress logging.

    For CUDA: shows allocated / reserved MB from torch.cuda.
    For MPS: falls back to process RSS (MPS uses unified memory, no per-device API).
    For CPU: shows process RSS only.
    """
    parts = []

    if device_type == "cuda":
        try:
            alloc = torch.cuda.memory_allocated() / (1024 ** 2)
            reserved = torch.cuda.memory_reserved() / (1024 ** 2)
            parts.append(f"cuda_alloc={alloc:.0f}MB reserved={reserved:.0f}MB")
        except Exception:
            pass

    rss = get_process_rss_mb()
    if rss is not None:
        parts.append(f"rss={rss:.0f}MB")

    return " | " + " | ".join(parts) if parts else ""


def get_dataloader_multiprocessing_context(num_workers, device_type, requested="auto"):
    """Choose a safe multiprocessing start method for the DataLoader.

    h5py is not fork-safe: accessing inherited file handles from multiple child
    processes causes HDF5 library errors or silent corruption.  On Linux the
    default start method is 'fork', so we override it to 'spawn' automatically.
    macOS defaults to 'spawn' (Python ≥ 3.8), so no override is needed there.

    Args:
        num_workers: DataLoader num_workers value.
        device_type: 'cuda', 'mps', or 'cpu'.
        requested: 'auto' lets this function decide; any other string is used as-is.

    Returns:
        A multiprocessing context string, or None (use PyTorch default).
    """
    if num_workers == 0:
        return None  # single-process mode; no context needed

    if requested != "auto":
        return requested  # user override

    system = platform.system()
    if system == "Linux":
        # Linux default is 'fork' which is not safe with h5py.
        return "spawn"

    if system == "Darwin":
        # macOS Python ≥ 3.8 defaults to 'spawn', but be explicit so the
        # log output and MPS+num_workers guidance are unambiguous.
        return "spawn"

    # Windows: platform default ('spawn') is already safe.
    return None


def load_picker_model(picker_model, device, device_type):
    picker = torch.jit.load(str(picker_model), map_location=device)
    picker.eval()
    picker.to(device)
    sync_device(device_type)
    return picker



def get_onnx_providers(device_type="cpu", requested="auto"):
    """Select ONNX Runtime providers for picker / polarity inference.

    device_type is the normalized runtime name from select_torch_device():
    "cuda", "mps", or "cpu".  ONNX Runtime does not have an MPS provider;
    on Apple Silicon / macOS acceleration is exposed through CoreMLExecutionProvider.
    """
    if ort is None:
        raise ImportError("onnxruntime is required for ONNX picker inference.")

    available = list(ort.get_available_providers())

    if requested and requested != "auto":
        providers = [x.strip() for x in str(requested).split(",") if x.strip()]
        providers = [p for p in providers if p in available]
        if "CPUExecutionProvider" not in providers and "CPUExecutionProvider" in available:
            providers.append("CPUExecutionProvider")
        if not providers:
            providers = ["CPUExecutionProvider"]
        return providers

    providers = []
    if device_type == "cuda" and "CUDAExecutionProvider" in available:
        providers.append("CUDAExecutionProvider")
    elif device_type == "mps":
        # ONNX Runtime acceleration on macOS is CoreML, not a literal MPS EP.
        if "CoreMLExecutionProvider" in available:
            providers.append("CoreMLExecutionProvider")

    if "CPUExecutionProvider" in available:
        providers.append("CPUExecutionProvider")

    return providers or available or ["CPUExecutionProvider"]


def load_onnx_picker_model(picker_model, device_type="cpu", providers="auto"):
    """Load ONNX picker model.

    Expected model interface:
      input:  "wave" with shape [T, 3], float32
      output: "prob" with shape [N, C], "time" with shape [N]
    """
    if ort is None:
        raise ImportError("onnxruntime is required for ONNX picker inference.")

    sess_options = ort.SessionOptions()
    try:
        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
    except Exception:
        pass

    selected = get_onnx_providers(device_type=device_type, requested=providers)
    print(f"[INFO] ONNX Runtime providers for picker model: {selected}")
    return ort.InferenceSession(str(picker_model), sess_options=sess_options, providers=selected)


def infer_picker_backend_from_suffix(picker_model):
    """Infer picker backend from model filename suffix.

    .onnx -> ONNX Runtime + external heap-NMS
    .jit/.torchscript/.pt/.pth -> TorchScript by default
    """
    suffix = Path(str(picker_model)).suffix.lower()
    if suffix == ".onnx":
        return "onnx"
    if suffix in (".jit", ".torchscript", ".pt", ".pth"):
        return "torchscript"
    # Keep historical behavior for unknown suffixes.
    return "torchscript"


def postprocess_picker_heap_nms(prob, time_values, prob_thresh=0.1, nms_win=200):
    """Heap-based NMS for ONNX picker outputs.

    prob: [N, C], where channel 0 is usually background and channels 1..C-1 are phases.
    time_values: [N], sample indices corresponding to prob rows.

    Returns ndarray [K, 3]: phase_id, sample_index, confidence.
    phase_id follows the TorchScript wrapper convention: channel 1 -> 0, channel 2 -> 1, etc.
    """
    prob = np.asarray(prob, dtype=np.float32)
    time_values = np.asarray(time_values, dtype=np.float32).reshape(-1)

    if prob.ndim != 2:
        raise ValueError(f"Expected ONNX prob with shape [N, C], got {prob.shape}")
    if time_values.ndim != 1:
        raise ValueError(f"Expected ONNX time with shape [N], got {time_values.shape}")
    if prob.shape[0] != time_values.shape[0]:
        raise ValueError(f"ONNX prob/time length mismatch: prob={prob.shape}, time={time_values.shape}")

    output = []
    n, c = prob.shape
    nms_win = float(nms_win)

    for itr in range(c - 1):
        pc = prob[:, itr + 1]
        mask = pc > float(prob_thresh)
        if not np.any(mask):
            continue

        time_sel = time_values[mask]
        score_sel = pc[mask]

        # Heap sorted by descending score using negative score.
        heap = [(-float(s), float(ts), i) for i, (s, ts) in enumerate(zip(score_sel, time_sel))]
        heapq.heapify(heap)

        accepted_times = []  # sorted by time
        accepted_idx = []

        while heap:
            neg_s, ts, i = heapq.heappop(heap)
            pos = bisect_left(accepted_times, ts)

            conflict = False
            if pos > 0 and abs(ts - accepted_times[pos - 1]) <= nms_win:
                conflict = True
            if pos < len(accepted_times) and abs(accepted_times[pos] - ts) <= nms_win:
                conflict = True

            if conflict:
                continue

            accepted_times.insert(pos, ts)
            accepted_idx.append(i)

        if not accepted_idx:
            continue

        p_time = time_sel[accepted_idx].astype(np.float32, copy=False)
        p_prob = score_sel[accepted_idx].astype(np.float32, copy=False)
        p_type = np.full(p_time.shape, itr, dtype=np.float32)
        output.append(np.stack([p_type, p_time, p_prob], axis=1))

    if not output:
        return np.zeros((0, 3), dtype=np.float32)

    return np.concatenate(output, axis=0).astype(np.float32, copy=False)


def run_onnx_picker_from_tensor(sess, x_cpu, prob_thresh=0.1, nms_win=200):
    """Run ONNX picker and external heap-NMS postprocessing.

    This replaces the slow TorchScript-internal NMS. The ONNX model should output
    dense probability/time arrays, and this function returns the final [K, 3]
    picks compatible with the rest of the JSONL writer.
    """
    if torch.is_tensor(x_cpu):
        x_np = x_cpu.detach().cpu().numpy()
    else:
        x_np = np.asarray(x_cpu)

    if x_np.ndim == 1:
        x_np = x_np[:, None]
    if x_np.shape[1] == 1:
        x_np = np.repeat(x_np, 3, axis=1)
    elif x_np.shape[1] > 3:
        x_np = x_np[:, :3]
    elif x_np.shape[1] < 3:
        pad = np.zeros((x_np.shape[0], 3 - x_np.shape[1]), dtype=x_np.dtype)
        x_np = np.concatenate([x_np, pad], axis=1)

    x_np = np.ascontiguousarray(x_np.astype(np.float32, copy=False))

    # Prefer named outputs, matching your ONNX example.  If names differ, fall back to positional outputs.
    try:
        prob, time_values = sess.run(["prob", "time"], {"wave": x_np})
    except Exception:
        outputs = sess.run(None, {"wave": x_np})
        if len(outputs) < 2:
            raise ValueError("ONNX picker must return at least two outputs: prob and time")
        prob, time_values = outputs[0], outputs[1]

    picks = postprocess_picker_heap_nms(
        prob,
        time_values,
        prob_thresh=prob_thresh,
        nms_win=nms_win,
    )
    return picks, np.asarray(prob), np.asarray(time_values)


def to_jsonable(obj):
    if torch.is_tensor(obj):
        return {
            "__tensor__": True,
            "shape": list(obj.shape),
            "dtype": str(obj.dtype),
        }

    if isinstance(obj, np.ndarray):
        return {
            "__ndarray__": True,
            "shape": list(obj.shape),
            "dtype": str(obj.dtype),
        }

    if isinstance(obj, (np.integer,)):
        return int(obj)

    if isinstance(obj, (np.floating,)):
        value = float(obj)
        if not np.isfinite(value):
            return None
        return value

    if isinstance(obj, (np.bool_,)):
        return bool(obj)

    if isinstance(obj, dict):
        return {str(k): to_jsonable(v) for k, v in obj.items()}

    if isinstance(obj, (list, tuple)):
        return [to_jsonable(v) for v in obj]

    if isinstance(obj, bytes):
        return obj.decode("utf-8", errors="ignore")

    if isinstance(obj, (datetime.datetime, datetime.date)):
        return obj.isoformat()

    try:
        json.dumps(obj)
        return obj
    except Exception:
        return str(obj)


def parse_starttime_to_datetime(starttime):
    if starttime is None or str(starttime).strip() == "":
        return None

    s = str(starttime).strip().replace("Z", "")

    try:
        return datetime.datetime.fromisoformat(s)
    except Exception:
        pass

    for fmt in [
        "%Y-%m-%dT%H:%M:%S.%f",
        "%Y-%m-%dT%H:%M:%S",
        "%Y-%m-%d %H:%M:%S.%f",
        "%Y-%m-%d %H:%M:%S",
    ]:
        try:
            return datetime.datetime.strptime(s, fmt)
        except Exception:
            continue

    return None


def isoformat_z(dt):
    if dt is None:
        return None
    return dt.isoformat(timespec="microseconds") + "Z"


def ensure_waveform_tensor_for_picker(waveform):
    """Return CPU float32 tensor with shape [T, 3] without unnecessary NumPy copies."""
    if torch.is_tensor(waveform):
        x = waveform.detach()
        if x.device.type != "cpu":
            x = x.cpu()
        if x.dtype != torch.float32:
            x = x.to(dtype=torch.float32)
    else:
        x = torch.from_numpy(np.asarray(waveform, dtype=np.float32))

    if x.ndim == 1:
        x = x[:, None]

    if x.shape[1] == 1:
        x = x.repeat(1, 3)
    elif x.shape[1] > 3:
        x = x[:, :3]
    elif x.shape[1] < 3:
        pad = torch.zeros((x.shape[0], 3 - x.shape[1]), dtype=x.dtype)
        x = torch.cat([x, pad], dim=1)

    if not x.is_contiguous():
        x = x.contiguous()

    return x


def get_z_component_numpy(waveform):
    """Return Z component as a NumPy view/copy with minimal conversion."""
    x = ensure_waveform_tensor_for_picker(waveform)
    z = x[:, 2]
    return z.numpy()


def run_torchscript_picker_from_tensor(sess, x_cpu, device):
    """Run picker using an already prepared CPU tensor [T, 3].

    This avoids constructing the full waveform tensor twice in one sample. The
    output is an ndarray with columns: phase_id, sample_index, confidence.
    """
    xt = None
    y = None
    out_cpu = None
    try:
        with torch.inference_mode():
            # non_blocking=True overlaps CPU→GPU PCIe transfer with other CUDA work.
            # For MPS (unified memory) and CPU it is a no-op but harmless.
            xt = x_cpu.to(device=device, dtype=torch.float32,
                          non_blocking=(device.type == "cuda"))
            y = sess(xt)

        # Move output back to CPU *before* deleting the MPS tensors so the
        # MPS allocator can reclaim the memory on the next empty_cache call.
        if torch.is_tensor(y):
            out_cpu = y.detach().cpu()
            del y
            y = None
            out = out_cpu.numpy().copy()  # copy so the tensor can be freed
            del out_cpu
            out_cpu = None
        else:
            out = np.asarray(y)

        # Release the device-side input tensor now that inference is done.
        del xt
        xt = None

        if out.ndim == 1:
            out = out[None, :]

        if out.shape[1] == 2:
            conf = np.ones((out.shape[0], 1), dtype=np.float32)
            out = np.concatenate([out, conf], axis=1)

        if out.shape[1] < 3:
            raise ValueError(f"Unexpected picker output shape: {out.shape}")

        return out[:, :3].astype(np.float32, copy=False)

    finally:
        del xt
        del y
        del out_cpu


def run_torchscript_picker(sess, waveform, device):
    """Backward-compatible wrapper."""
    x_cpu = ensure_waveform_tensor_for_picker(waveform)
    try:
        return run_torchscript_picker_from_tensor(sess, x_cpu, device)
    finally:
        del x_cpu

def compute_pick_quality(z, sample_index, sr, snr_window_sec=2.0):
    z = np.asarray(z, dtype=np.float32)
    pidx = int(round(sample_index))

    if len(z) == 0 or not np.isfinite(sr) or float(sr) <= 0:
        return {
            "snr": None,
            "amplitude": None,
            "pre_std": None,
            "post_std": None,
            "pre_abs_p95": None,
            "post_abs_p95": None,
        }

    win = max(1, int(round(float(snr_window_sec) * float(sr))))

    b0 = max(0, pidx - win)
    b1 = max(0, pidx)
    a0 = min(len(z), pidx)
    a1 = min(len(z), pidx + win)

    pre = z[b0:b1]
    post = z[a0:a1]

    if len(pre) == 0:
        pre = np.ones(win, dtype=np.float32)
    if len(post) == 0:
        post = np.ones(win, dtype=np.float32)

    pre_centered = pre - np.mean(pre)
    post_centered = post - np.mean(post)

    pre_std = float(np.std(pre_centered))
    post_std = float(np.std(post_centered))
    snr = post_std / (pre_std + 1e-6)

    amp_end = min(len(z), pidx + int(round(1.0 * float(sr))))
    amp_start = max(0, pidx - int(round(0.2 * float(sr))))
    amp_win = z[amp_start:amp_end]

    amplitude = float(np.max(np.abs(amp_win))) if len(amp_win) > 0 else None

    return {
        "snr": float(snr),
        "amplitude": amplitude,
        "pre_std": pre_std,
        "post_std": post_std,
        "pre_abs_p95": float(np.percentile(np.abs(pre_centered), 95)),
        "post_abs_p95": float(np.percentile(np.abs(post_centered), 95)),
    }


def load_polar_model(polar_model, device_name="cpu", providers="auto"):
    if not polar_model:
        return None

    if ort is None:
        raise ImportError("onnxruntime is required for polar model inference.")

    selected = get_onnx_providers(device_type=device_name, requested=providers)
    print(f"[INFO] ONNX Runtime providers for polarity model: {selected}")
    return ort.InferenceSession(str(polar_model), providers=selected)


def run_polar_picker(polar_sess, z, sample_index):
    """
    Input: Z component, 1024 samples around Pg.
    Output:
        polarity: U/D/N
        polarity probability
    """
    if polar_sess is None:
        return "N", 0.0

    z = np.asarray(z, dtype=np.float32)

    if len(z) == 0:
        return "N", 0.0

    pidx = int(round(sample_index))

    if pidx <= 512:
        pidx = 512
    if pidx >= len(z) - 512:
        pidx = len(z) - 512

    if pidx < 0:
        return "N", 0.0

    pdata = z[pidx - 512:pidx + 512]

    if len(pdata) > 1024:
        pdata = pdata[:1024]
    if len(pdata) < 1024:
        pdata = np.pad(pdata, (0, 1024 - len(pdata)))

    pdata = np.ascontiguousarray(pdata.astype(np.float32, copy=False))
    prob, = polar_sess.run(["prob"], {"wave": pdata})
    prob = np.asarray(prob).reshape(-1)

    polar_id = int(np.argmax(prob))
    polar_prob = float(np.max(prob))

    if polar_id == 0:
        return "U", polar_prob
    if polar_id == 1:
        return "D", polar_prob

    return "N", polar_prob


def get_station_info_compact(item):
    info = item.get("station_info", {})

    return {
        "station_id": item.get("station_id", ""),
        "network": info.get("network", ""),
        "station": info.get("station", ""),
        "location": info.get("location", ""),
        "longitude": info.get("longitude", None),
        "latitude": info.get("latitude", None),
        "elevation": info.get("elevation", None),
        "location_available": bool(info.get("location_available", False)),
        "position_in_time_range": (
            str(info.get("position_match_mode", ""))
            == "strict_time_matched_network_station_only"
        ),
        "position_is_fallback": bool(info.get("position_is_fallback", False)),
    }


def make_sample_key_from_item(item):
    """Build the same key that make_sample_key_from_index_item would produce.

    Must stay in sync with make_sample_key_from_index_item in
    utils/hdf5_waveform_dataset.py so that no_pick / error sentinel records
    have keys that match the dataset's resume filter.

    Z-only replicated stations: __getitem__ stores ["EHZ","EHZ","EHZ"] in
    item["channels"] but the index was built from the raw ["EHZ"] list.
    Deduplicate here so the key matches.
    """
    channels = item.get("channels") or []
    # Deduplicate for Z-only replicated stations so key matches the index.
    if item.get("z_only_replicated", False):
        seen: set = set()
        channels = [ch for ch in channels if not (ch in seen or seen.add(ch))]
    channels = ",".join(str(x) for x in channels)

    return "|".join([
        str(item.get("h5_file", "")),
        str(item.get("year_id", "")),
        str(item.get("day_id", "")),
        str(item.get("station_id", "")),
        str(item.get("channel_family", item.get("channel", ""))),
        channels,
    ])


def build_pick_record(
    item,
    z,
    phase_id,
    sample_index,
    confidence,
    polar_sess=None,
    snr_window_sec=2.0,
):
    sr = float(item.get("sampling_rate", np.nan))
    phase_id = int(phase_id)
    sample_index = float(sample_index)
    confidence = float(confidence)

    phase_name = PHASE_ID_TO_NAME.get(phase_id, f"phase_{phase_id}")

    if np.isfinite(sr) and sr > 0:
        phase_relative_time = sample_index / sr
    else:
        phase_relative_time = None

    start_dt = parse_starttime_to_datetime(item.get("starttime", ""))

    if start_dt is not None and phase_relative_time is not None:
        phase_dt = start_dt + datetime.timedelta(seconds=phase_relative_time)
    else:
        phase_dt = None

    quality = compute_pick_quality(
        z,
        sample_index=sample_index,
        sr=sr,
        snr_window_sec=snr_window_sec,
    )

    polarity = "N"
    polarity_prob = 0.0

    if phase_name == "Pg":
        polarity, polarity_prob = run_polar_picker(
            polar_sess,
            z,
            sample_index=sample_index,
        )

    record = {
        "record_type": "phase_pick",
        "phase_id": phase_id,
        "phase_name": phase_name,
        "phase_prob": confidence,
        "phase_sample": sample_index,
        "phase_relative_time": phase_relative_time,
        "phase_time": isoformat_z(phase_dt),
        "polarity": polarity,
        "polarity_prob": polarity_prob,
        "polarity_available": bool(polar_sess is not None and phase_name == "Pg"),
        "snr": quality.get("snr", None),
        "amplitude": quality.get("amplitude", None),
        "pre_std": quality.get("pre_std", None),
        "post_std": quality.get("post_std", None),
        "pre_abs_p95": quality.get("pre_abs_p95", None),
        "post_abs_p95": quality.get("post_abs_p95", None),
        "channels": item.get("channels", []),
        "channel_family": item.get("channel_family", ""),
        "component_order": item.get("component_order", ""),
        "is_z_only": bool(item.get("is_z_only", False)),
        "z_only_replicated": bool(item.get("z_only_replicated", False)),
        "waveform_shape": list(item["waveform"].shape),
        "sampling_rate": item.get("sampling_rate", None),
        "original_sampling_rate": item.get("original_sampling_rate", None),
        "target_sampling_rate": item.get("target_sampling_rate", None),
        "resampled": bool(item.get("resampled", False)),
        "h5_file": item.get("h5_file", ""),
        "year_id": item.get("year_id", ""),
        "day_id": item.get("day_id", ""),
        # station_id MUST be a top-level field: load_finished_sample_keys rebuilds
        # the resume key from h5_file|year_id|day_id|station_id|channel_family|channels
        # using item.get("station_id", "").  If it is only inside station_info the
        # scanner always sees "" and no record is ever marked as finished.
        "station_id": item.get("station_id", ""),
        "station_info": get_station_info_compact(item),
    }

    return to_jsonable(record)


def create_dataset_with_resume_filter(
    h5_input,
    output_jsonl,
    resume,
    allowed_families,
    allowed_z_only_channels,
    allow_z_only,
    replicate_z_only,
    target_sampling_rate,
    include_segments_metadata,
    keep_h5_open,
    use_overlap_mask,
    h5_rdcc_nbytes=8 * 1024 * 1024,
    max_duration_sec=90000.0,
):
    kwargs = dict(
        h5_file=h5_input,
        mode="three",
        allowed_families=allowed_families,
        allowed_z_only_channels=allowed_z_only_channels,
        allow_z_only=allow_z_only,
        replicate_z_only=replicate_z_only,
        target_sampling_rate=target_sampling_rate,
        fill_value=0.0,
        dtype=np.float32,
        default_location="--",
    )

    # These options exist in the revised loader. If the old loader is imported by
    # accident, the TypeError fallback keeps the script usable, but resume filtering
    # will not be memory-safe until utils/hdf5_waveform_dataset_resume.py is used.
    if resume:
        kwargs["skip_jsonl"] = output_jsonl
        kwargs["skip_record_type"] = "phase_pick"
    kwargs["keep_h5_open"] = keep_h5_open
    kwargs["include_segments_metadata"] = include_segments_metadata
    kwargs["use_overlap_mask"] = use_overlap_mask
    kwargs["h5_rdcc_nbytes"] = h5_rdcc_nbytes
    kwargs["max_duration_sec"] = max_duration_sec

    try:
        return HDF5WaveformDataset(**kwargs), True
    except TypeError as e:
        print("[WARN] Resume-aware loader options were rejected by HDF5WaveformDataset.")
        print(f"[WARN] Details: {e}")
        print("[WARN] Falling back to the old loader API; skip will not happen before waveform loading.")
        for key in [
            "skip_jsonl",
            "skip_record_type",
            "keep_h5_open",
            "include_segments_metadata",
            "use_overlap_mask",
            "h5_rdcc_nbytes",
            "max_duration_sec",
        ]:
            kwargs.pop(key, None)
        return HDF5WaveformDataset(**kwargs), False


def run_picker_to_jsonl(
    h5_input,
    output_jsonl,
    picker_model,
    polar_model=None,
    picker_backend="auto",
    onnx_providers="auto",
    onnx_prob_thresh=0.1,
    onnx_nms_win=200,
    device_name="auto",
    batch_size=1,
    num_workers=0,
    allowed_families=("HH", "BH", "EH", "HN"),
    allowed_z_only_channels=("EHZ",),
    allow_z_only=True,
    replicate_z_only=True,
    target_sampling_rate=100.0,
    min_confidence=0.0,
    snr_window_sec=2.0,
    progress_interval=100,
    resume=True,
    flush_interval=1000,
    gc_interval=2000,
    include_segments_metadata=False,
    keep_h5_open=True,
    use_overlap_mask=True,
    mps_empty_cache_interval=1,
    cuda_empty_cache_interval=200,
    reload_model_interval=-1,
    multiprocessing_context="auto",
    prefetch_factor=2,
    h5_rdcc_nbytes=8 * 1024 * 1024,
    max_samples=0,
    canonical_input_length=0,
    auto_restart=True,
    sample_timeout=120,
    max_picks_per_sample=0,
    max_duration_sec=90000.0,
    slow_load_threshold=10.0,
    slow_infer_threshold=10.0,
    slow_post_threshold=10.0,
    slow_total_threshold=30.0,
    flush_no_pick=False,
):
    t_all0 = time.perf_counter()

    device, device_type = select_torch_device(device_name)

    # Resolve reload_model_interval: -1 means auto-select per device.
    # MPS: reloading the model resets the TorchScript allocator state and
    # avoids unbounded RSS growth — but also triggers Metal kernel
    # recompilation on the very first inference after each reload, which
    # can take 30–300 s and blocks the GPU for that entire period.
    #
    # When max_samples > 0 the process is restarted via os.execv after
    # every N samples, which already resets all Metal state cleanly.
    # Within a single max_samples run there is no benefit to mid-run
    # reloading — it only adds compilation overhead.
    if reload_model_interval == -1:
        if device_type == "mps":
            if max_samples > 0:
                # os.execv handles memory reset; no mid-run reload needed.
                effective_reload_interval = 0
            else:
                # Unlimited run: reload periodically to prevent RSS growth,
                # but much less frequently than the old default of 50.
                effective_reload_interval = 500
        else:
            effective_reload_interval = 0
    else:
        effective_reload_interval = reload_model_interval

    # Resolve canonical_input_length.
    # -1 is the sentinel from argparse; treat it the same as 0 (disabled).
    # The feature must be opted in explicitly via --canonical_input_length N
    # because many models (e.g. EQTransformer) use fixed internal windows that
    # break when the input tensor is padded to an unexpected length.
    if canonical_input_length <= 0:
        canonical_input_length = 0

    # Resolve picker backend from suffix unless explicitly specified.
    picker_backend = str(picker_backend).lower().strip()
    if picker_backend == "auto":
        picker_backend = infer_picker_backend_from_suffix(picker_model)
    if picker_backend not in ("torchscript", "onnx"):
        raise ValueError(
            f"Unsupported picker_backend={picker_backend!r}. Use 'auto', 'torchscript', or 'onnx'."
        )

    # Resolve DataLoader multiprocessing context.
    mp_context = get_dataloader_multiprocessing_context(
        num_workers, device_type, multiprocessing_context
    )

    print("=" * 80)
    print("[INFO] Starting phase picking")
    print(f"[INFO] HDF5 input: {h5_input}")
    print(f"[INFO] Output JSONL: {output_jsonl}")
    print(f"[INFO] Picker model: {picker_model}")
    print(f"[INFO] Picker backend: {picker_backend}")
    if str(picker_backend).lower() == "onnx":
        print(f"[INFO] ONNX picker postprocess: prob_thresh={onnx_prob_thresh}, nms_win={onnx_nms_win}")
        print(f"[INFO] ONNX provider request: {onnx_providers}")
    print(f"[INFO] Polarity model: {polar_model if polar_model else 'disabled'}")
    print(f"[INFO] Requested device: {device_name}")
    print(f"[INFO] Using torch device: {device}")
    print(f"[INFO] Target sampling rate: {target_sampling_rate}")
    print(f"[INFO] Resume: {resume}")
    print(f"[INFO] batch_size={batch_size}, num_workers={num_workers}")
    if num_workers > 0:
        print(f"[INFO] multiprocessing_context={mp_context!r}  prefetch_factor={prefetch_factor}")
    print(f"[INFO] mps_empty_cache_interval={mps_empty_cache_interval}")
    print(f"[INFO] cuda_empty_cache_interval={cuda_empty_cache_interval}")
    print(f"[INFO] reload_model_interval={effective_reload_interval}"
          f"  (requested={reload_model_interval})")
    print(f"[INFO] h5_rdcc_nbytes={h5_rdcc_nbytes // (1024*1024)} MB per file handle (only current file kept open)")
    print(f"[INFO] max_duration_sec={max_duration_sec}")
    print(
        f"[INFO] slow thresholds: load>{slow_load_threshold}s, infer>{slow_infer_threshold}s, "
        f"post>{slow_post_threshold}s, total>{slow_total_threshold}s"
    )
    _mps_str = str(max_picks_per_sample) if max_picks_per_sample > 0 else "0 (no limit)"
    print(f"[INFO] max_picks_per_sample={_mps_str}  flush_no_pick={flush_no_pick}")
    if canonical_input_length > 0:
        print(f"[INFO] canonical_input_length={canonical_input_length} samples "
              f"(all inputs padded/trimmed to this length to fix Metal pipeline cache growth)")
        if target_sampling_rate and target_sampling_rate > 0:
            full_day = int(86400 * target_sampling_rate)
            if canonical_input_length >= full_day:
                print(
                    f"[WARN] canonical_input_length={canonical_input_length} is a full day "
                    f"({full_day} @ {target_sampling_rate:.0f} Hz). Gappy or short station-days "
                    f"will be zero-padded to this length. For sliding-window models such as "
                    f"EQTransformer this multiplies the number of inference windows proportionally "
                    f"and can make per-sample runtime 10–100× slower on days with many gaps. "
                    f"Consider removing --canonical_input_length for EQTransformer."
                )
    else:
        print(f"[INFO] canonical_input_length=disabled")
        if target_sampling_rate and target_sampling_rate > 0:
            suggested = int(86400 * target_sampling_rate)
            # EQTransformer has an internal buffer of size 2*input_length; passing
            # exactly 2*input_length as an index overflows by 1.  Use suggested-2
            # as the safe EQTransformer ceiling.
            suggested_eqt = suggested - 2
            if device_type == "mps":
                print(
                    f"[WARN] MPS + canonical_input_length=disabled: every waveform with "
                    f"a unique sample count triggers a NEW Metal shader compilation. "
                    f"Python SIGALRM cannot interrupt Metal C-layer compilation, so the "
                    f"script will hang indefinitely on each new shape.\n"
                    f"[WARN] Fix: add  --canonical_input_length {suggested_eqt}  to your "
                    f"command. This pads/trims all waveforms to one shape so Metal "
                    f"compiles exactly once. ({suggested_eqt} = 86400 s × "
                    f"{target_sampling_rate:.0f} Hz − 2, safe for EQTransformer.)"
                )
            else:
                print(
                    f"[INFO] Tip: --canonical_input_length {suggested} "
                    f"({int(86400)} s × {target_sampling_rate:.0f} Hz) fixes the Metal "
                    f"kernel to one shape (MPS only). "
                    f"For EQTransformer use {suggested_eqt} instead (avoids internal OOB)."
                )
    if _SIGALRM_AVAILABLE and sample_timeout > 0:
        print(f"[INFO] sample_timeout={sample_timeout}s  "
              f"(SIGALRM watchdog; hangs exceeding this are written as error records)")
    else:
        reason = "disabled by --sample_timeout 0" if sample_timeout <= 0 else "SIGALRM not available on this platform"
        print(f"[INFO] sample_timeout=off  ({reason})")
    print("=" * 80)

    output_jsonl = Path(output_jsonl)
    output_jsonl.parent.mkdir(parents=True, exist_ok=True)

    t0 = time.perf_counter()
    if picker_backend == "onnx":
        picker = load_onnx_picker_model(picker_model, device_type=device_type, providers=onnx_providers)
    else:
        picker = load_picker_model(picker_model, device, device_type)
    print(f"[INFO] Picker model loaded in {format_seconds(time.perf_counter() - t0)}")

    t0 = time.perf_counter()
    polar_sess = load_polar_model(polar_model, device_name=device_type, providers=onnx_providers)
    print(f"[INFO] Polarity model loaded in {format_seconds(time.perf_counter() - t0)}")

    t0 = time.perf_counter()
    dataset, resume_filter_is_loader_level = create_dataset_with_resume_filter(
        h5_input=h5_input,
        output_jsonl=output_jsonl,
        resume=resume,
        allowed_families=allowed_families,
        allowed_z_only_channels=allowed_z_only_channels,
        allow_z_only=allow_z_only,
        replicate_z_only=replicate_z_only,
        target_sampling_rate=target_sampling_rate,
        include_segments_metadata=include_segments_metadata,
        keep_h5_open=keep_h5_open,
        use_overlap_mask=use_overlap_mask,
        h5_rdcc_nbytes=h5_rdcc_nbytes,
        max_duration_sec=max_duration_sec,
    )

    total_dataset_samples = len(dataset)

    print(f"[INFO] Dataset indexed in {format_seconds(time.perf_counter() - t0)}")
    print(f"[INFO] Number of HDF5 files: {len(dataset.h5_files)}")
    if hasattr(dataset, "original_index_size"):
        print(f"[INFO] Original samples before resume filtering: {dataset.original_index_size}")
        print(f"[INFO] Samples filtered before waveform loading: {dataset.filtered_index_size}")
    print(f"[INFO] Number of samples to process now: {total_dataset_samples}")
    if max_samples > 0:
        restart_mode = "auto os.execv restart" if auto_restart else "exit code 75 (bash loop)"
        print(f"[INFO] max_samples={max_samples}: {restart_mode} after {max_samples} new samples.")
    elif device_type == "mps":
        print("[WARN] MPS detected with max_samples=0 (unlimited run).")
        print("[WARN] The Metal allocator and CoreML/ONNX Runtime accumulate process-level")
        print("[WARN] state that Python cannot free.  RSS will grow ~20-45 MB/sample early on.")
        print("[WARN] Strongly recommended: add --max_samples 200 (auto_restart is on by default)")
        print("[WARN] so the script restarts itself transparently until all samples are done.")
    if hasattr(dataset, "skip_jsonl_stats") and dataset.skip_jsonl_stats:
        print(f"[INFO] Resume JSONL stats: {dataset.skip_jsonl_stats}")
    print(f"[INFO] Loader-level resume filtering active: {resume_filter_is_loader_level}")

    if device_type == "mps":
        if num_workers == 0:
            print(
                "[INFO] Tip (MPS): --num_workers 1 --multiprocessing_context spawn "
                "enables a background CPU worker to prefetch+decode HDF5 waveforms "
                "while the GPU runs inference, which can significantly improve GPU "
                "utilisation. Workers never touch MPS; 'spawn' is macOS default."
            )
        else:
            # Workers run on CPU only (HDF5 decode). MPS state lives in the main
            # process. This is safe; just confirm spawn context is in use.
            if mp_context not in ("spawn", None):
                print(f"[WARN] MPS+num_workers: multiprocessing_context={mp_context!r}; "
                      f"consider 'spawn' (macOS default) to avoid h5py issues.")
            else:
                print(f"[INFO] MPS+num_workers={num_workers}: workers do CPU-only HDF5 "
                      f"decoding (safe). GPU inference runs in main process.")
    elif device_type == "cuda" and num_workers == 0:
        print("[INFO] Tip: --num_workers 4 (or more) enables parallel waveform "
              "prefetching on CUDA and can significantly improve throughput.")

    loader_kwargs = dict(
        batch_size=batch_size,
        shuffle=False,
        num_workers=num_workers,
        collate_fn=waveform_collate_fn,
        # pin_memory speeds up CPU→GPU transfers on CUDA.
        pin_memory=(device_type == "cuda"),
        persistent_workers=(num_workers > 0),
    )
    if num_workers > 0:
        loader_kwargs["prefetch_factor"] = prefetch_factor
        loader_kwargs["multiprocessing_context"] = mp_context
        # hdf5_worker_init_fn resets inherited h5 handles when using 'fork'.
        # It is a no-op with 'spawn'/'forkserver' but safe to always pass.
        loader_kwargs["worker_init_fn"] = hdf5_worker_init_fn

    loader = DataLoader(dataset, **loader_kwargs)

    # ── Metal kernel pre-warmup (MPS only) ──────────────────────────────────
    # On the first run (or after a Metal cache clear), PyTorch/Metal must
    # JIT-compile GPU shaders for every unique input tensor shape encountered.
    # For a model like EQTransformer this can take 5–15 minutes with ZERO
    # console output, making the script appear completely hung.
    #
    # Running a dummy inference here triggers compilation *before* the main
    # loop so the user can see what's happening.  No SIGALRM applies during
    # warmup; the per-sample timeout only guards the main loop.
    # Compiled kernels are cached to ~/Library/Caches/com.apple.metal/ and
    # are re-used automatically on subsequent runs (warmup then takes < 1 s).
    if device_type == "mps" and picker_backend == "torchscript":
        _sr = target_sampling_rate if (target_sampling_rate and target_sampling_rate > 0) else 100.0
        if canonical_input_length > 0:
            _warmup_len = canonical_input_length
        else:
            # canonical_input_length is disabled: warmup uses the full-day shape,
            # but real waveforms will differ → Metal recompiles per unique length.
            # SIGALRM cannot interrupt Metal C-layer compilation, so those will hang.
            # The warning above (at startup) already told the user to add the flag.
            _warmup_len = int(86400 * _sr) - 2  # EQTransformer-safe default
        print(
            f"[INFO] MPS: running Metal kernel pre-warmup "
            f"(dummy inference on a {_warmup_len:,}-sample zero tensor). "
            f"If this is the first run for this model, Metal shader compilation "
            f"may take 5–15 min — this is NORMAL and will only happen once. "
            f"Kernels are cached to ~/Library/Caches/com.apple.metal/.",
            flush=True,
        )
        _t_warmup = time.perf_counter()
        try:
            with torch.inference_mode():
                # Shape must match what run_torchscript_picker_from_tensor passes:
                # ensure_waveform_tensor_for_picker returns [T, 3] (2-D, not batched).
                _dummy_cpu = torch.zeros(_warmup_len, 3, dtype=torch.float32)
                _dummy_gpu = _dummy_cpu.to(device)
                del _dummy_cpu
                _warmup_out = picker(_dummy_gpu)
                del _dummy_gpu, _warmup_out
                torch.mps.synchronize()
            _warmup_elapsed = time.perf_counter() - _t_warmup
            if _warmup_elapsed >= 5.0:
                print(
                    f"[INFO] Metal warmup complete in {format_seconds(_warmup_elapsed)}. "
                    f"Kernels are now cached — main loop inference will be fast.",
                    flush=True,
                )
            else:
                print(
                    f"[INFO] Metal warmup complete in {format_seconds(_warmup_elapsed)} "
                    f"(kernels were already cached).",
                    flush=True,
                )
        except Exception as _warmup_exc:
            print(
                f"[WARN] Metal warmup failed: {_warmup_exc}  "
                f"Continuing — first sample in the main loop may be slow.",
                flush=True,
            )

    total_seen = 0
    total_processed = 0
    total_picks = 0
    total_errors = 0
    total_written_lines = 0

    t_loop0 = time.perf_counter()
    t_last = t_loop0

    open_mode = "a" if resume else "w"
    _max_samples_reached = False

    print("[INFO] Entering main processing loop...", flush=True)
    try:
        with open(output_jsonl, open_mode, encoding="utf-8", buffering=1024 * 1024) as f:
            # ── Manual DataLoader iteration ────────────────────────────────
            # We use iter(loader)+next() instead of `for batch in loader` so
            # that we can arm the SIGALRM watchdog BEFORE the HDF5 read.
            # With num_workers=0, `next(loader_iter)` calls dataset.__getitem__
            # synchronously in the main thread.  A blocked HDF5 syscall IS
            # interruptible by SIGALRM (POSIX signals interrupt IO syscalls),
            # so arming here covers both the waveform-load and inference phases.
            loader_iter = iter(loader)
            _loop_done = False
            while not _loop_done:
                # Declare per-sample state before arming the watchdog so the
                # outer except and finally can always reference these names.
                sample_key = ""
                item = None
                z = picks = x_cpu = waveform = original_length = None
                _hdf5_fetched = False

                _timer = _SampleTimer(sample_timeout)
                _timer.__enter__()
                # Print a loading marker before every HDF5 read so slow reads
                # are never confused with a hung process.
                _load_t0 = time.perf_counter()
                #print(
                #    f"[LOAD] {total_seen + 1}/{total_dataset_samples} "
                #    f"(HDF5 read)...",
                #    flush=True,
                #)
                try:
                    # ── Fetch next batch (HDF5 waveform read) ─────────────
                    # With num_workers=0 this runs in the main thread; the HDF5
                    # C library retries EINTR internally, so SIGALRM cannot
                    # reliably interrupt it.  Use --num_workers 1 to move the
                    # read into a subprocess; the main process then blocks on
                    # queue.get() which IS Python-level and interruptible.
                    try:
                        batch = next(loader_iter)
                    except StopIteration:
                        _loop_done = True
                        break       # outer finally still runs to disarm timer

                    _load_elapsed = time.perf_counter() - _load_t0
                    _hdf5_fetched = True
                    if _load_elapsed >= slow_load_threshold:
                        print(
                            f"[SLOW_LOAD] next_batch={format_seconds(_load_elapsed)} "
                            f"batch_size={len(batch)} num_workers={num_workers} "
                            f"prefetch_factor={prefetch_factor}",
                            flush=True,
                        )
                    else:
                        #print(
                        #    f"[LOAD_DONE] next_batch={format_seconds(_load_elapsed)} "
                        #    f"batch_size={len(batch)}",
                        #    flush=True,
                        #)
                        pass

                    for item in batch:
                        _sample_t0 = time.perf_counter()
                        _prep_elapsed = 0.0
                        _infer_elapsed = 0.0
                        _post_elapsed = 0.0
                        _pick_count_written = 0
                        _pick_count_model = 0
                        _pick_count_after_filter = 0
                        _post_t0 = None
                        sample_meta = {}
                        total_seen += 1
                        total_processed += 1

                        # Capture the sample key and lightweight metadata now, before
                        # deleting waveform tensors.  This is used for slow-sample logs
                        # and error records.
                        sample_key = make_sample_key_from_item(item)
                        sample_meta = {
                            "station_id": item.get("station_id", ""),
                            "h5_file": item.get("h5_file", ""),
                            "year_id": item.get("year_id", ""),
                            "day_id": item.get("day_id", ""),
                            "channels": item.get("channels", []),
                            "channel_family": item.get("channel_family", ""),
                            "sampling_rate": item.get("sampling_rate", None),
                            "original_sampling_rate": item.get("original_sampling_rate", None),
                            "starttime": item.get("starttime", ""),
                            "endtime": item.get("endtime", ""),
                            "npts": item.get("npts", None),
                        }

                        try:
                            # ── Per-sample inference ───────────────────────
                            # NOTE: _timer is already armed above (before the
                            # HDF5 read); do NOT create or re-arm it here.
                            _prep_t0 = time.perf_counter()
                            waveform = item["waveform"]
                            # Build the full [T, 3] CPU tensor exactly once.
                            # This avoids two large copies for day-long waveforms.
                            x_cpu = ensure_waveform_tensor_for_picker(waveform)
                            original_length = x_cpu.shape[0]
                            _prep_elapsed = time.perf_counter() - _prep_t0

                            # ── Canonical-length padding ───────────────────
                            # On MPS, TorchScript compiles and caches a separate
                            # Metal pipeline for every unique input tensor shape.
                            # Padding every input to one canonical length means
                            # Metal compiles exactly ONE set of kernels and never
                            # allocates another pipeline object.
                            # Picks whose sample_index >= original_length are
                            # filtered out below to suppress padding artefacts.
                            if canonical_input_length > 0 and original_length != canonical_input_length:
                                if original_length < canonical_input_length:
                                    pad = torch.zeros(
                                        canonical_input_length - original_length,
                                        x_cpu.shape[1],
                                        dtype=x_cpu.dtype,
                                    )
                                    x_cpu = torch.cat([x_cpu, pad], dim=0)
                                else:
                                    x_cpu = x_cpu[:canonical_input_length]

                            z = x_cpu[:original_length, 2].numpy()

                            _t_infer = time.perf_counter()
                            _onnx_prob_rows = 0
                            _onnx_prob_shape = ""
                            if picker_backend == "onnx":
                                picks, _prob_raw, _time_raw = run_onnx_picker_from_tensor(
                                    picker,
                                    x_cpu,
                                    prob_thresh=onnx_prob_thresh,
                                    nms_win=onnx_nms_win,
                                )
                                _onnx_prob_rows = int(_prob_raw.shape[0]) if hasattr(_prob_raw, "shape") else 0
                                _onnx_prob_shape = safe_shape_text(_prob_raw)
                                # Release dense ONNX outputs immediately; they can be large for full-day traces.
                                del _prob_raw, _time_raw
                            else:
                                picks = run_torchscript_picker_from_tensor(
                                    picker,
                                    x_cpu,
                                    device=device,
                                )
                            _infer_elapsed = time.perf_counter() - _t_infer
                            _pick_count_model = int(len(picks)) if picks is not None else 0
                            # Print one line per sample so slow HDF5 reads and slow
                            # inferences are both immediately visible in the log.
                            _extra = ""
                            if picker_backend == "onnx":
                                _extra = f" prob_shape={_onnx_prob_shape} prob_rows={_onnx_prob_rows}"
                            #print(
                            #    f"[INFER] {total_processed}: "
                            #    f"{original_length:,}samp "
                            #    f"backend={picker_backend} "
                            #    f"prep={format_seconds(_prep_elapsed)} "
                            #    f"infer+postnms={format_seconds(_infer_elapsed)} "
                            #    f"model_picks={_pick_count_model}"
                            #    f"{_extra}",
                            #    flush=True,
                            #)

                            # Remove any picks the model placed in the padded tail.
                            if canonical_input_length > 0 and picks is not None and len(picks) > 0:
                                picks = picks[picks[:, 1] < original_length]

                        except Exception as e:
                            _timer.__exit__(type(e), e, None)   # disarm SIGALRM
                            total_errors += 1
                            is_timeout = isinstance(e, _SampleTimeout)
                            err_record = {
                                "record_type": "error",
                                "station_id": item.get("station_id", ""),
                                "h5_file": item.get("h5_file", ""),
                                "year_id": item.get("year_id", ""),
                                "day_id": item.get("day_id", ""),
                                "sample_key": sample_key,
                                "error": str(e),
                            }
                            f.write(_json_dumps(to_jsonable(err_record)) + "\n")
                            f.flush()
                            total_written_lines += 1
                            try:
                                if item is not None and "waveform" in item:
                                    del item["waveform"]
                            except Exception:
                                pass
                            picks = z = x_cpu = waveform = None
                            item = None
                            if is_timeout:
                                # A timeout means a Metal / ONNX operation may still
                                # be in-flight.  Do NOT call synchronize() or
                                # empty_cache() — they can themselves block on the
                                # orphaned operation and cause a cascade hang.
                                print(
                                    f"[WARN] Sample timed out after {sample_timeout}s "
                                    f"(skipping, Metal ops will drain at next restart): "
                                    f"{sample_key}",
                                    flush=True,
                                )
                            else:
                                if device_type == "mps":
                                    force_device_cleanup(device_type, do_gc=False)
                            continue

                        _picks_before = total_picks
                        try:
                            # Cap picks per station-day.
                            _above = picks[picks[:, 2] >= min_confidence] if min_confidence > 0 else picks
                            if max_picks_per_sample > 0 and len(_above) > max_picks_per_sample:
                                _order = _above[:, 2].argsort()[::-1]
                                _above = _above[_order[:max_picks_per_sample]]
                            picks = _above
                            _pick_count_after_filter = int(len(picks)) if picks is not None else 0
                            _post_t0 = time.perf_counter()

                            for row in picks:
                                phase_id = int(row[0])
                                sample_index = float(row[1])
                                confidence = float(row[2])

                                record = build_pick_record(
                                    item=item,
                                    z=z,
                                    phase_id=phase_id,
                                    sample_index=sample_index,
                                    confidence=confidence,
                                    polar_sess=polar_sess,
                                    snr_window_sec=snr_window_sec,
                                )

                                f.write(_json_dumps(record) + "\n")
                                total_picks += 1
                                total_written_lines += 1
                                _pick_count_written += 1

                        finally:
                            if _post_t0 is not None:
                                try:
                                    _post_elapsed = time.perf_counter() - _post_t0
                                except Exception:
                                    _post_elapsed = 0.0
                            # Disarm the SIGALRM watchdog on the normal success path.
                            _timer.__exit__(None, None, None)
                            picks = z = x_cpu = waveform = None
                            try:
                                del item["waveform"]
                            except Exception:
                                pass
                            item = None

                        # ── No-pick sentinel ───────────────────────────────
                        # If this station-day produced zero detections write a
                        # lightweight record so the resume scanner marks it done.
                        if total_picks == _picks_before:
                            _no_pick = {"record_type": "no_pick", "sample_key": sample_key}
                            f.write(_json_dumps(_no_pick) + "\n")
                            if flush_no_pick:
                                f.flush()
                            total_written_lines += 1

                        _sample_elapsed = time.perf_counter() - _sample_t0
                        if (
                            _load_elapsed >= slow_load_threshold
                            or _infer_elapsed >= slow_infer_threshold
                            or _post_elapsed >= slow_post_threshold
                            or _sample_elapsed >= slow_total_threshold
                        ):
                            _meta = dict(sample_meta)
                            if _meta.get("npts") is None:
                                _meta["npts"] = original_length
                            print(
                                "[SLOW_SAMPLE] "
                                f"idx={total_processed} "
                                f"load_batch={format_seconds(_load_elapsed)} "
                                f"prep={format_seconds(_prep_elapsed)} "
                                f"infer={format_seconds(_infer_elapsed)} "
                                f"post_write={format_seconds(_post_elapsed)} "
                                f"sample_total={format_seconds(_sample_elapsed)} "
                                f"model_picks={_pick_count_model} "
                                f"kept_picks={_pick_count_after_filter} "
                                f"written_picks={_pick_count_written} "
                                f"shape={original_length:,}x3 "
                                f"meta={to_jsonable(_meta)}",
                                flush=True,
                            )

                        # ── Per-sample allocator cleanup ───────────────────
                        if device_type == "mps" and mps_empty_cache_interval > 0 and total_processed % mps_empty_cache_interval == 0:
                            force_device_cleanup(device_type, do_gc=True)
                        elif device_type == "cuda" and cuda_empty_cache_interval > 0 and total_processed % cuda_empty_cache_interval == 0:
                            force_device_cleanup(device_type, do_gc=False)

                        # ── Periodic h5py handle flush ─────────────────────
                        if effective_reload_interval > 0 and total_processed % effective_reload_interval == 0:
                            try:
                                dataset.flush_h5_cache()
                            except Exception:
                                pass

                        # ── Periodic model reload ──────────────────────────
                        if effective_reload_interval > 0 and total_processed % effective_reload_interval == 0:
                            sync_device(device_type)
                            del picker
                            if polar_sess is not None:
                                del polar_sess
                                polar_sess = None
                            gc.collect()
                            empty_device_cache(device_type)
                            if picker_backend == "onnx":
                                picker = load_onnx_picker_model(picker_model, device_type=device_type, providers=onnx_providers)
                            else:
                                picker = load_picker_model(picker_model, device, device_type)
                            if polar_model:
                                polar_sess = load_polar_model(polar_model, device_name=device_type, providers=onnx_providers)
                            gc.collect()
                            empty_device_cache(device_type)

                        if flush_interval > 0 and total_processed % flush_interval == 0:
                            f.flush()

                        if gc_interval > 0 and total_processed % gc_interval == 0 and device_type != "mps":
                            gc.collect()
                            empty_device_cache(device_type)

                        if (
                            total_seen % max(1, progress_interval) == 0
                            or total_seen == total_dataset_samples
                        ):
                            sync_device(device_type)
                            now = time.perf_counter()
                            elapsed = now - t_loop0
                            speed = total_seen / max(elapsed, 1e-6)

                            if total_dataset_samples > 0:
                                progress = total_seen / total_dataset_samples
                                remaining = total_dataset_samples - total_seen
                                eta = remaining / max(speed, 1e-6)
                            else:
                                progress = 0.0
                                eta = 0.0

                            recent_elapsed = now - t_last
                            t_last = now

                            mem_text = get_device_memory_text(device_type)
                            print(
                                "[PROGRESS] "
                                f"{total_seen}/{total_dataset_samples} "
                                f"({progress * 100:.2f}%) | "
                                f"processed={total_processed} | "
                                f"picks={total_picks} | "
                                f"errors={total_errors} | "
                                f"speed={speed:.3f} samples/s | "
                                f"elapsed={format_seconds(elapsed)} | "
                                f"eta={format_seconds(eta)} | "
                                f"last_interval={format_seconds(recent_elapsed)}"
                                f"{mem_text}"
                            )

                        # ── max_samples early-exit ─────────────────────────
                        if max_samples > 0 and total_processed >= max_samples:
                            _max_samples_reached = True
                            break   # break for-item loop

                except _SampleTimeout:
                    # This fires only when the timeout occurs in next(loader_iter)
                    # (HDF5 IO).  Timeouts during inference are _SampleTimeout
                    # subclasses of Exception and are caught by the inner except.
                    #
                    # NOTE: with num_workers=0 the HDF5 C library retries EINTR
                    # internally, so SIGALRM may not fire until the read eventually
                    # completes or exceeds sample_timeout at a Python check-point.
                    # With num_workers>=1 the main process blocks in Python-level
                    # queue.get(), which IS interruptible, so timeout is reliable.
                    total_errors += 1
                    err_record = {
                        "record_type": "error",
                        "sample_key": sample_key,   # "" if timeout before item was known
                        "error": f"HDF5 read timed out after {sample_timeout}s",
                    }
                    f.write(_json_dumps(to_jsonable(err_record)) + "\n")
                    f.flush()
                    total_written_lines += 1
                    print(
                        f"[WARN] HDF5 read timed out after {sample_timeout}s "
                        f"(sample will be retried on next run)",
                        flush=True,
                    )
                    # With num_workers > 0 the worker process that hung is still
                    # running in the background.  Recreating the iterator drops the
                    # reference to the old loader state and spawns a fresh worker,
                    # so subsequent samples are not blocked by the stuck process.
                    if num_workers > 0:
                        print(
                            "[INFO] Restarting DataLoader to replace the hung "
                            "worker process.",
                            flush=True,
                        )
                        try:
                            del loader_iter
                        except Exception:
                            pass
                        loader_iter = iter(loader)
                    # Do NOT call synchronize()/empty_cache() after a timeout.

                finally:
                    # Always disarm; calling __exit__ multiple times is safe
                    # (signal.alarm(0) is idempotent).
                    _timer.__exit__(None, None, None)
                    # Release any refs left by an HDF5-timeout path.
                    picks = z = x_cpu = waveform = None
                    if item is not None:
                        try:
                            del item["waveform"]
                        except Exception:
                            pass
                    item = None

                if _max_samples_reached:
                    break   # break while loop

            f.flush()

    finally:
        try:
            dataset.close()
        except Exception:
            pass
        gc.collect()
        empty_device_cache(device_type)

    total_elapsed = time.perf_counter() - t_all0
    loop_elapsed = time.perf_counter() - t_loop0

    print("=" * 80)
    print("[OK] Phase picking finished")
    print(f"[OK] Dataset samples seen by DataLoader: {total_seen}")
    print(f"[OK] Samples newly processed: {total_processed}")
    print(f"[OK] Phase picks written: {total_picks}")
    print(f"[OK] JSONL lines written this run: {total_written_lines}")
    print(f"[OK] Errors: {total_errors}")
    print(f"[OK] Output JSONL: {output_jsonl}")
    print(f"[OK] Processing time: {format_seconds(loop_elapsed)}")
    print(f"[OK] Total wall time: {format_seconds(total_elapsed)}")
    if hasattr(dataset, "filtered_index_size"):
        print(f"[OK] Samples skipped before waveform loading: {dataset.filtered_index_size}")
    if total_seen > 0:
        print(f"[OK] Average speed: {total_seen / max(loop_elapsed, 1e-6):.3f} samples/s")
        print(f"[OK] Average time per sample: {loop_elapsed / total_seen:.3f} s/sample")
    if total_picks > 0:
        print(f"[OK] Average time per pick: {loop_elapsed / total_picks:.3f} s/pick")
    if _max_samples_reached:
        print(f"[OK] Stopped early: max_samples={max_samples} reached.")
        if auto_restart:
            print(f"[OK] auto_restart=True — re-executing this process now to free all OS-level "
                  f"Metal / CoreML allocator state (RSS will reset to baseline).")
        else:
            print(f"[OK] auto_restart=False — exiting with code 75. "
                  f"Re-run with --resume to continue from the next sample.")
    print("=" * 80)

    if _max_samples_reached:
        sys.stdout.flush()
        sys.stderr.flush()
        if auto_restart:
            # os.execv replaces this process image with a fresh Python process running
            # the same script and arguments.  The OS reclaims ALL Metal / CoreML /
            # HDF5 allocator state (things that empty_cache and gc.collect cannot touch).
            # --resume is enabled by default so the new process skips already-written
            # samples at the dataset level without re-reading any waveform data.
            os.execv(sys.executable, [sys.executable] + sys.argv)
        else:
            sys.exit(75)


def parse_tuple_arg(value):
    if value is None or str(value).strip() == "":
        return tuple()
    return tuple(x.strip().upper() for x in str(value).split(",") if x.strip())


def main():
    parser = argparse.ArgumentParser(
        description="Run TorchScript or ONNX seismic picker on HDF5 dataloader samples and write JSONL output."
    )

    parser.add_argument(
        "--h5_input",
        default="data/hdf5/continuous_waveform_usa_*.h5",
        help='HDF5 file, directory, or glob pattern.',
    )
    parser.add_argument(
        "--output_jsonl",
        default="data/picks/pnsn.v1.phase.jsonl",
        help="Output JSONL file.",
    )
    parser.add_argument(
        "--picker_model",
        default="pickers/pnsn.v1.diff.jit",
        help="Picker model path. Suffix .onnx uses ONNX Runtime; .jit/.torchscript uses TorchScript by default.",
    )
    parser.add_argument(
        "--picker_backend",
        default="auto",
        choices=["auto", "torchscript", "onnx"],
        help=(
            "Picker backend. Default 'auto' chooses by --picker_model suffix: "
            ".onnx -> ONNX Runtime + external heap-NMS; "
            ".jit/.torchscript -> TorchScript. "
            "Use 'torchscript' or 'onnx' to override."
        ),
    )
    parser.add_argument(
        "--onnx_providers",
        default="auto",
        help=(
            "ONNX Runtime provider list. Use 'auto' to select CUDA for --device cuda, "
            "CoreML for --device mps, and CPU otherwise. You can also pass an explicit "
            "comma-separated list such as CUDAExecutionProvider,CPUExecutionProvider."
        ),
    )
    parser.add_argument(
        "--onnx_prob_thresh",
        type=float,
        default=0.1,
        help="Probability threshold for external heap-NMS ONNX picker post-processing.",
    )
    parser.add_argument(
        "--onnx_nms_win",
        type=int,
        default=200,
        help="NMS window in samples for external heap-NMS ONNX picker post-processing.",
    )
    parser.add_argument(
        "--polar_model",
        default=None,
        help="Optional ONNX polar model path. Use empty string to disable.",
    )
    parser.add_argument(
        "--device",
        default="auto",
        choices=["auto", "cpu", "cuda", "mps"],
        help="Inference device: auto, cpu, cuda, or mps.",
    )
    parser.add_argument(
        "--batch_size",
        type=int,
        default=1,
        help="Batch size. Samples are still processed one by one inside each batch.",
    )
    parser.add_argument(
        "--num_workers",
        type=int,
        default=0,
        help=(
            "Number of DataLoader worker processes for parallel waveform prefetching. "
            "0 = single-process (default). "
            "MPS: 1 worker overlaps HDF5 decode (CPU) with GPU inference; workers never "
            "touch MPS so this is safe — use with --multiprocessing_context spawn "
            "(macOS default). "
            "CUDA: 4–8 workers is a good starting point to hide HDF5 I/O latency. "
            "On Linux, workers use 'spawn' by default (see --multiprocessing_context) "
            "to avoid h5py + fork conflicts."
        ),
    )
    parser.add_argument(
        "--prefetch_factor",
        type=int,
        default=2,
        help=(
            "Number of batches pre-loaded per worker (PyTorch default=2). "
            "Reduce to 1 if workers OOM on large waveforms. "
            "Ignored when num_workers=0."
        ),
    )
    parser.add_argument(
        "--multiprocessing_context",
        default="auto",
        help=(
            "Multiprocessing start method for DataLoader workers: "
            "'auto' (default) selects 'spawn' on Linux to avoid h5py+fork issues, "
            "and the OS default elsewhere. "
            "Other valid values: 'spawn', 'fork', 'forkserver'. "
            "If you use 'fork', the hdf5_worker_init_fn is automatically applied "
            "to reset inherited HDF5 file handles in each worker. "
            "Ignored when num_workers=0."
        ),
    )
    parser.add_argument(
        "--allowed_families",
        default="HH,BH,EH,HN",
        help='Comma-separated channel families, e.g. "HH,BH,EH,HN".',
    )
    parser.add_argument(
        "--allowed_z_only_channels",
        default="EHZ",
        help='Comma-separated Z-only channels, e.g. "EHZ".',
    )
    parser.add_argument(
        "--allow_z_only",
        action="store_true",
        default=True,
        help="Allow Z-only samples.",
    )
    parser.add_argument(
        "--no_z_only",
        action="store_false",
        dest="allow_z_only",
        help="Disable Z-only samples.",
    )
    parser.add_argument(
        "--replicate_z_only",
        action="store_true",
        default=True,
        help="Replicate Z-only samples to [Z, Z, Z].",
    )
    parser.add_argument(
        "--no_replicate_z_only",
        action="store_false",
        dest="replicate_z_only",
        help="Do not replicate Z-only samples.",
    )
    parser.add_argument(
        "--target_sampling_rate",
        type=float,
        default=100.0,
        help="Target sampling rate in Hz. Use -1 to disable resampling.",
    )
    parser.add_argument(
        "--min_confidence",
        type=float,
        default=0.0,
        help="Minimum pick confidence to write.",
    )
    parser.add_argument(
        "--snr_window_sec",
        type=float,
        default=2.0,
        help="SNR window length before and after pick, in seconds.",
    )
    parser.add_argument(
        "--progress_interval",
        type=int,
        default=100,
        help="Print progress every N samples.",
    )
    parser.add_argument(
        "--flush_interval",
        type=int,
        default=100,
        help="Flush JSONL file every N processed samples. Use 0 to flush only at the end.",
    )
    parser.add_argument(
        "--gc_interval",
        type=int,
        default=500,
        help="Run gc.collect and empty device cache every N samples. Use 0 to disable.",
    )
    parser.add_argument(
        "--resume",
        action="store_true",
        default=True,
        help="Resume from existing JSONL and skip already processed samples before waveform loading.",
    )
    parser.add_argument(
        "--no_resume",
        action="store_false",
        dest="resume",
        help="Disable resume mode and overwrite output JSONL.",
    )
    parser.add_argument(
        "--include_segments_metadata",
        action="store_true",
        default=False,
        help="Return segment metadata from the loader. Default False saves memory.",
    )
    parser.add_argument(
        "--no_keep_h5_open",
        action="store_false",
        dest="keep_h5_open",
        default=True,
        help="Disable per-process cached HDF5 handles.",
    )
    parser.add_argument(
        "--mps_empty_cache_interval",
        type=int,
        default=500,
        help="For MPS, synchronize + gc.collect + torch.mps.empty_cache every N processed samples. Use 0 to disable.",
    )
    parser.add_argument(
        "--cuda_empty_cache_interval",
        type=int,
        default=500,
        help="For CUDA, synchronize + torch.cuda.empty_cache every N processed samples. Use 0 to disable.",
    )
    parser.add_argument(
        "--reload_model_interval",
        type=int,
        default=-1,
        help=(
            "Reload TorchScript model every N processed samples. "
            "-1 (default) = auto: 50 for MPS (Metal allocator state accumulates "
            "with each TorchScript call; reload is the only way to reset it), "
            "0 (disabled) for CUDA and CPU. "
            "Increase if reload overhead is noticeable on very short waveforms. "
            "Set 0 to disable entirely."
        ),
    )
    parser.add_argument(
        "--no_overlap_mask",
        action="store_false",
        dest="use_overlap_mask",
        default=True,
        help="Disable overlap mask in fill_segments_to_array to reduce memory.",
    )
    parser.add_argument(
        "--h5_rdcc_nbytes",
        type=int,
        default=8 * 1024 * 1024,
        help=(
            "HDF5 raw-data chunk cache size in bytes per open file handle "
            "(default: 8388608 = 8 MB). h5py's built-in default is 1 MB. "
            "8 MB is enough for single-pass inference; only the current file's "
            "handle is kept open — stale file handles are closed as soon as the "
            "loader moves to the next file, so chunk-cache memory stays O(1). "
            "Raise to 64 MB for repeated-access / training workloads."
        ),
    )
    parser.add_argument(
        "--canonical_input_length",
        type=int,
        default=0,
        help=(
            "Pad or trim every waveform to exactly N samples before sending to "
            "the picker model. Default 0 = disabled (recommended). "
            "WARNING: many models (e.g. EQTransformer) use fixed-size internal "
            "windows and will crash or produce wrong results if the input tensor "
            "length differs from what the model expects. Only enable if you know "
            "your model supports variable-length inputs and benefits from a fixed "
            "shape (e.g. to control TorchScript Metal pipeline cache growth). "
            "Picks placed in the padded tail (sample_index >= original length) "
            "are filtered out automatically."
        ),
    )
    parser.add_argument(
        "--max_samples",
        type=int,
        default=0,
        help=(
            "Restart the process after processing N new samples. "
            "With --auto_restart (default), the script calls os.execv to replace "
            "itself with a fresh process, freeing all Metal / CoreML / HDF5 "
            "allocator state that Python cannot reclaim. "
            "--resume is enabled by default, so the new process skips already-written "
            "samples at the dataset level. "
            "0 = no limit (process all samples without restart). "
            "Recommended on Mac/MPS to keep RSS bounded: --max_samples 200."
        ),
    )
    parser.add_argument(
        "--auto_restart",
        action="store_true",
        default=True,
        help=(
            "When --max_samples is reached, use os.execv to restart this process "
            "instead of exiting with code 75. "
            "The OS reclaims all Metal / CoreML / HDF5 allocator state on process "
            "replacement; the new process resumes from where the previous one stopped. "
            "Default: True (recommended for MPS). "
            "Use --no_auto_restart to get exit-code-75 behavior for external bash loops."
        ),
    )
    parser.add_argument(
        "--no_auto_restart",
        action="store_false",
        dest="auto_restart",
        help="Disable auto os.execv restart; exit with code 75 when --max_samples is reached.",
    )
    parser.add_argument(
        "--sample_timeout",
        type=int,
        default=600,
        help=(
            "Maximum seconds allowed to process a single sample before the "
            "watchdog (SIGALRM) fires and the sample is written as an error "
            "record.  Prevents the script from hanging indefinitely on a stuck "
            "Metal / ONNX Runtime operation.  "
            "0 = disabled.  Default: 120 s.  "
            "Only effective on Unix/macOS (SIGALRM is not available on Windows)."
        ),
    )
    parser.add_argument(
        "--max_picks_per_sample",
        type=int,
        default=0,
        help=(
            "Maximum phase detections to write per station-day.  When more "
            "picks are detected (e.g. on a major-earthquake day with thousands "
            "of aftershocks), the top-N by confidence are kept and the rest "
            "are discarded.  This prevents the per-pick CoreML polarity loop "
            "from running for hundreds of seconds and triggering the "
            "--sample_timeout watchdog.  0 = no limit (default). "
            "Recommended on MPS/Apple Silicon when processing high-seismicity days: 500-2000."
        ),
    )
    parser.add_argument(
        "--max_duration_sec",
        type=float,
        default=90000.0,
        help=(
            "Maximum allowed time span for one consolidated channel waveform. "
            "Default 90000 s = 25 h. If a channel has bad start/end metadata and "
            "would allocate an abnormal array, the loader raises an error instead "
            "of appearing to hang."
        ),
    )
    parser.add_argument(
        "--slow_load_threshold",
        type=float,
        default=10.0,
        help="Print [SLOW_LOAD]/[SLOW_SAMPLE] when DataLoader/HDF5 batch fetch exceeds this many seconds.",
    )
    parser.add_argument(
        "--slow_infer_threshold",
        type=float,
        default=10.0,
        help="Print [SLOW_SAMPLE] when TorchScript model inference exceeds this many seconds.",
    )
    parser.add_argument(
        "--slow_post_threshold",
        type=float,
        default=10.0,
        help="Print [SLOW_SAMPLE] when post-processing / SNR / polarity / JSONL writing exceeds this many seconds.",
    )
    parser.add_argument(
        "--slow_total_threshold",
        type=float,
        default=30.0,
        help="Print [SLOW_SAMPLE] when total per-sample time excluding batch fetch exceeds this many seconds.",
    )
    parser.add_argument(
        "--flush_no_pick",
        action="store_true",
        default=False,
        help=(
            "Flush output JSONL immediately after every no_pick sentinel. "
            "Default False because flushing every no-pick sample can be slow on "
            "external disks or network filesystems."
        ),
    )
    args = parser.parse_args()

    target_sampling_rate = args.target_sampling_rate
    if target_sampling_rate is not None and target_sampling_rate <= 0:
        target_sampling_rate = None

    run_picker_to_jsonl(
        h5_input=args.h5_input,
        output_jsonl=args.output_jsonl,
        picker_model=args.picker_model,
        polar_model=args.polar_model if args.polar_model else None,
        picker_backend=args.picker_backend,
        onnx_providers=args.onnx_providers,
        onnx_prob_thresh=args.onnx_prob_thresh,
        onnx_nms_win=args.onnx_nms_win,
        device_name=args.device,
        batch_size=args.batch_size,
        num_workers=args.num_workers,
        allowed_families=parse_tuple_arg(args.allowed_families),
        allowed_z_only_channels=parse_tuple_arg(args.allowed_z_only_channels),
        allow_z_only=args.allow_z_only,
        replicate_z_only=args.replicate_z_only,
        target_sampling_rate=target_sampling_rate,
        min_confidence=args.min_confidence,
        snr_window_sec=args.snr_window_sec,
        progress_interval=args.progress_interval,
        resume=args.resume,
        flush_interval=args.flush_interval,
        gc_interval=args.gc_interval,
        include_segments_metadata=args.include_segments_metadata,
        keep_h5_open=args.keep_h5_open,
        use_overlap_mask=args.use_overlap_mask,
        mps_empty_cache_interval=args.mps_empty_cache_interval,
        cuda_empty_cache_interval=args.cuda_empty_cache_interval,
        reload_model_interval=args.reload_model_interval,
        multiprocessing_context=args.multiprocessing_context,
        prefetch_factor=args.prefetch_factor,
        h5_rdcc_nbytes=args.h5_rdcc_nbytes,
        max_samples=args.max_samples,
        canonical_input_length=args.canonical_input_length,
        auto_restart=args.auto_restart,
        sample_timeout=args.sample_timeout,
        max_picks_per_sample=args.max_picks_per_sample,
        max_duration_sec=args.max_duration_sec,
        slow_load_threshold=args.slow_load_threshold,
        slow_infer_threshold=args.slow_infer_threshold,
        slow_post_threshold=args.slow_post_threshold,
        slow_total_threshold=args.slow_total_threshold,
        flush_no_pick=args.flush_no_pick,
    )


if __name__ == "__main__":
    main()