Fix pipeline bugs and sync cluster code changes

- pipeline02: fix ffprobe multi-stream parsing (int() crash on '1080\n\n1920x1080');
integrate processed_complete counter increment on successful processing
- pipeline03: fix cleanup_local_assets() missing stats_npz argument (caused every
upload to exit with RuntimeError after successful upload); add counter decrement
on local cleanup
- runtime_status.py: guard du -sb behind --scan-runtime-size flag (was blocking
unconditionally); add fast_count_complete(), --scan-csv and --scan-complete flags
- reproduce_independently_slurm.sh: add run_upload_drain_stage() and upload
configuration vars (UPLOAD_PARALLEL_SHARDS, UPLOAD_PARTITION, etc.)
- utils/dataset_pool.py: prefer scratch over home when scratch has .complete marker;
better conflict resolution for duplicate video dirs across home/scratch
- utils/stats_npz.py: add adjust_processed_complete_counter(),
processed_complete_counter_path(), read_processed_complete_counter()

reproduce_independently_slurm.sh

@@ -30,6 +30,7 @@ PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_captio
 PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
 PIPELINE03="${PIPELINE03:-$ROOT_DIR/scripts/pipeline03_upload_to_huggingface.py}"
 PIPELINE_SYNC="${PIPELINE_SYNC:-$ROOT_DIR/scripts/sync_processed_csv_from_runtime.py}"
+UPLOAD_DRAIN_SCRIPT="${UPLOAD_DRAIN_SCRIPT:-$ROOT_DIR/slurm/submit_upload_parallel_drain.sh}"
 
 STAGE="${STAGE:-all}"
 LIMIT="${LIMIT:-}"
@@ -38,6 +39,11 @@ FPS="${FPS:-24}"
 WORKERS="${WORKERS:-}"
 TARGET_BYTES="${TARGET_BYTES:-$((10 * 1024 * 1024 * 1024))}"
 TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
+UPLOAD_PARALLEL_SHARDS="${UPLOAD_PARALLEL_SHARDS:-8}"
+UPLOAD_ARRAY_PARALLEL="${UPLOAD_ARRAY_PARALLEL:-8}"
+UPLOAD_PARTITION="${UPLOAD_PARTITION:-main}"
+UPLOAD_START_STAGGER_MIN="${UPLOAD_START_STAGGER_MIN:-1}"
+UPLOAD_START_STAGGER_MAX="${UPLOAD_START_STAGGER_MAX:-3}"
 DOWNLOAD_BATCH_SIZE="${DOWNLOAD_BATCH_SIZE:-1}"
 DOWNLOAD_WORKERS="${DOWNLOAD_WORKERS:-60}"
 USE_SLURM_DOWNLOAD="${USE_SLURM_DOWNLOAD:-1}"
@@ -616,6 +622,25 @@ run_upload_stage() {
   run_in_dwpose "${cmd[@]}"
 }
 
+run_upload_drain_stage() {
+  local cmd=(
+    env
+    ROOT_DIR="$ROOT_DIR"
+    RUNTIME_ROOT="$RUNTIME_ROOT"
+    TARGET_BYTES="$TARGET_BYTES"
+    TARGET_FOLDERS="$TARGET_FOLDERS"
+    PARALLEL_SHARDS="$UPLOAD_PARALLEL_SHARDS"
+    ARRAY_PARALLEL="$UPLOAD_ARRAY_PARALLEL"
+    PARTITION="$UPLOAD_PARTITION"
+    START_STAGGER_MIN="$UPLOAD_START_STAGGER_MIN"
+    START_STAGGER_MAX="$UPLOAD_START_STAGGER_MAX"
+    REPO_ID="$REPO_ID"
+    REPO_REVISION="$REPO_REVISION"
+    bash "$UPLOAD_DRAIN_SCRIPT"
+  )
+  run_in_dwpose "${cmd[@]}"
+}
+
 prune_processed_raw_videos() {
   python - <<PY
 from pathlib import Path
@@ -1421,12 +1446,8 @@ upload_loop() {
       continue
     fi
 
-    local require_target=1
-    if [[ "$pending_download" -eq 0 && "$pending_process" -eq 0 ]]; then
-      require_target=0
-    fi
-    if ! run_upload_stage "$require_target"; then
-      echo "[upload] pipeline03 failed; retry after sleep"
+    if ! run_upload_drain_stage; then
+      echo "[upload] upload drain failed; retry after sleep"
       sleep "$IDLE_SLEEP_SECONDS"
     else
       run_sync_csv_stage >/dev/null 2>&1 || true

scripts/pipeline02_extract_dwpose_from_video.py

@@ -29,7 +29,12 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import load_stats, update_video_stats_best_effort
+from utils.stats_npz import (
+    adjust_processed_complete_counter,
+    load_stats,
+    processed_complete_counter_path,
+    update_video_stats_best_effort,
+)
 from utils.raw_video_pool import iter_raw_video_files
 from utils.dataset_pool import dataset_dir_for_video, find_dataset_video_dir
 
@@ -250,9 +255,11 @@ def probe_video_dimensions(video_path: Path) -> Tuple[int, int]:
         str(video_path),
     ]
     proc = subprocess.run(command, check=True, capture_output=True, text=True)
-    dims = (proc.stdout or "").strip()
-    if "x" not in dims:
-        raise RuntimeError(f"Unable to parse ffprobe dimensions for {video_path.name}: {dims!r}")
+    raw = proc.stdout or ""
+    # ffprobe may emit multiple lines for videos with multiple streams; take the first valid one
+    dims = next((line.strip() for line in raw.splitlines() if "x" in line.strip()), "").strip()
+    if not dims or "x" not in dims:
+        raise RuntimeError(f"Unable to parse ffprobe dimensions for {video_path.name}: {raw!r}")
     width_s, height_s = dims.split("x", 1)
     return int(width_s), int(height_s)
 
@@ -588,13 +595,15 @@ def process_video(
     optimized_frame_batch_size: int,
     optimized_detect_resolution: int,
     optimized_frame_stride: int,
+    stats_npz: Path,
 ) -> None:
     video_id = video_path.stem
     output_dataset_dir = dataset_dir_for_video(video_path, raw_video_dir, scratch_raw_video_dir, dataset_dir, scratch_dataset_dir)
     output_npz_dir = output_dataset_dir / video_id / "npz"
     complete_marker = output_npz_dir / COMPLETE_MARKER_NAME
+    was_complete = complete_marker.exists()
     poses_npz_path = output_npz_dir / "poses.npz"
-    if output_npz_dir.exists() and complete_marker.exists() and not force:
+    if output_npz_dir.exists() and was_complete and not force:
         print(f"Skip {video_id}: NPZ files already exist")
         return
 
@@ -716,6 +725,8 @@ def process_video(
         f"video_id={video_id}\nfps={fps}\nframes={total_frames}\noutput_mode={'single_poses_npy' if single_poses_npz else 'per_frame_npz'}\ndecode_mode={'stream' if stream_frames else 'jpg-spill'}\noptimized_mode={optimized_mode}\noptimized_detect_resolution={optimized_detect_resolution}\noptimized_frame_stride={optimized_frame_stride}\ncompleted_at={time.strftime('%Y-%m-%d %H:%M:%S')}\n",
         encoding="utf-8",
     )
+    if not was_complete:
+        adjust_processed_complete_counter(processed_complete_counter_path(stats_npz), 1)
 
 
 def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argparse.Namespace) -> None:
@@ -769,6 +780,7 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
                 optimized_frame_batch_size=args.optimized_frame_batch_size,
                 optimized_detect_resolution=args.optimized_detect_resolution,
                 optimized_frame_stride=args.optimized_frame_stride,
+                stats_npz=args.stats_npz,
             )
             update_video_stats_best_effort(
                 args.stats_npz,

scripts/pipeline03_upload_to_huggingface.py

@@ -24,7 +24,12 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import apply_status_journal_to_stats, update_many_video_stats_with_retry
+from utils.stats_npz import (
+    adjust_processed_complete_counter,
+    apply_status_journal_to_stats,
+    processed_complete_counter_path,
+    update_many_video_stats_with_retry,
+)
 from utils.dataset_pool import find_dataset_video_dir, list_unuploaded_folder_paths as list_unuploaded_folder_paths_pool
 
 
@@ -418,11 +423,15 @@ def cleanup_local_assets(
     scratch_raw_video_dir: Path | None,
     raw_caption_dir: Path,
     raw_metadata_dir: Path,
+    stats_npz: Path,
 ) -> None:
     for video_id in video_ids:
         dataset_video_dir = find_dataset_video_dir(video_id, dataset_dir, scratch_dataset_dir)
+        had_complete = (dataset_video_dir / "npz" / COMPLETE_MARKER_NAME).exists()
         if dataset_video_dir.exists():
             shutil.rmtree(dataset_video_dir, ignore_errors=True)
+        if had_complete:
+            adjust_processed_complete_counter(processed_complete_counter_path(stats_npz), -1)
         for raw_dir in [raw_video_dir, scratch_raw_video_dir]:
             if raw_dir is None:
                 continue
@@ -445,6 +454,7 @@ def prune_uploaded_runtime_residue(
     scratch_raw_video_dir: Path | None,
     raw_caption_dir: Path,
     raw_metadata_dir: Path,
+    stats_npz: Path | None = None,
 ) -> None:
     uploaded = set(progress.get("uploaded_folders", {}))
     for video_id in uploaded:
@@ -461,8 +471,11 @@ def prune_uploaded_runtime_residue(
         if metadata_path.exists():
             metadata_path.unlink(missing_ok=True)
         dataset_video_dir = find_dataset_video_dir(video_id, dataset_dir, scratch_dataset_dir)
-        if dataset_video_dir.exists() and not (dataset_video_dir / "npz" / COMPLETE_MARKER_NAME).exists():
+        had_complete = (dataset_video_dir / "npz" / COMPLETE_MARKER_NAME).exists()
+        if dataset_video_dir.exists():
             shutil.rmtree(dataset_video_dir, ignore_errors=True)
+        if had_complete and stats_npz is not None:
+            adjust_processed_complete_counter(processed_complete_counter_path(stats_npz), -1)
 
 
 def format_size(num_bytes: int) -> str:
@@ -525,6 +538,7 @@ def main() -> None:
                 args.scratch_raw_video_dir,
                 args.raw_caption_dir,
                 args.raw_metadata_dir,
+                args.stats_npz,
             )
             remaining_folder_paths = list_unuploaded_folder_paths(args.dataset_dir, args.scratch_dataset_dir, progress)
             remaining_folder_paths = filter_folders_for_shard(remaining_folder_paths, args.parallel_shards, args.shard_index)
@@ -665,6 +679,7 @@ def main() -> None:
                 args.scratch_raw_video_dir,
                 args.raw_caption_dir,
                 args.raw_metadata_dir,
+                args.stats_npz,
             )
             if archive_path.exists():
                 archive_path.unlink(missing_ok=True)

scripts/runtime_status.py

@@ -10,7 +10,8 @@ import subprocess
 from collections import Counter
 from pathlib import Path
 
-from utils.dataset_pool import count_complete
+from utils.stats_npz import processed_complete_counter_path, read_processed_complete_counter
+
 
 VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'}
 ARRAY_RANGE_RE = re.compile(r'^(\d+)_\[(.+)\]$')
@@ -248,6 +249,23 @@ def read_source_manifest_count(path: Path) -> int:
     return count
 
 
+def fast_count_complete(dataset_dir: Path, scratch_dataset_dir: Path) -> int:
+    roots = [str(p) for p in (dataset_dir, scratch_dataset_dir) if p.exists()]
+    if not roots:
+        return 0
+    cmd = ['find', *roots, '-path', '*/npz/.complete']
+    try:
+        proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    except OSError:
+        return 0
+    if proc.returncode not in (0, 1):
+        return 0
+    out = proc.stdout
+    if not out:
+        return 0
+    return sum(1 for line in out.splitlines() if line.strip())
+
+
 def read_processed_progress(path: Path) -> dict[str, object]:
     result = {
         'csv_exists': path.exists(),
@@ -334,6 +352,7 @@ def main() -> None:
     parser.add_argument('--no-sync', action='store_true')
     parser.add_argument('--json', action='store_true')
     parser.add_argument('--include-partitions', action='store_true')
+    parser.add_argument('--scan-csv', action='store_true')
     parser.add_argument('--scan-complete', action='store_true')
     parser.add_argument('--scan-runtime-size', action='store_true')
     args = parser.parse_args()
@@ -369,7 +388,7 @@ def main() -> None:
 
     raw_size = sum_file_sizes(list(raw_complete.values()))
     runtime_size = 0
-    if runtime_root.exists():
+    if args.scan_runtime_size and runtime_root.exists():
         proc = subprocess.run(['du', '-sb', str(runtime_root)], check=False, capture_output=True, text=True)
         if proc.returncode == 0 and proc.stdout.strip():
             try:
@@ -378,7 +397,22 @@ def main() -> None:
                 runtime_size = 0
 
     source_rows = read_source_manifest_count(source_csv)
-    progress = read_processed_progress(processed_csv)
+    if args.scan_csv:
+        progress = read_processed_progress(processed_csv)
+    else:
+        progress = {
+            'csv_exists': processed_csv.exists(),
+            'csv_ok': False,
+            'csv_error': 'skipped',
+            'processed_rows': 0,
+            'download_ok_rows': 0,
+            'download_skipped_rows': 0,
+            'download_running_rows': 0,
+            'download_pending_rows': 0,
+            'process_ok_rows': 0,
+            'process_running_rows': 0,
+            'upload_uploaded_rows': 0,
+        }
     videos_per_dwpose_job = read_videos_per_dwpose_job(root_dir)
 
     payload = {
@@ -387,7 +421,7 @@ def main() -> None:
         'raw_videos': len(raw_complete),
         'raw_temp_files': len(raw_temp),
         'sent_to_gpu': count_claims(claims_dir),
-        'processed_complete': count_complete(dataset_dir, scratch_dataset_dir),
+        'processed_complete': read_processed_complete_counter(processed_complete_counter_path(runtime_root / 'stats.npz')),
         'active_downloads': count_claims(download_claims_dir),
         'uploaded_archives': 0,
         'uploaded_folders': 0,

utils/dataset_pool.py

@@ -31,7 +31,14 @@ def iter_dataset_video_dirs(home_dataset_dir: Path, scratch_dataset_dir: Path |
         for folder_path in sorted(dataset_dir.iterdir()):
             if not folder_path.is_dir():
                 continue
-            seen.setdefault(folder_path.name, folder_path)
+            existing = seen.get(folder_path.name)
+            if existing is None:
+                seen[folder_path.name] = folder_path
+                continue
+            existing_complete = (existing / "npz" / COMPLETE_MARKER_NAME).exists()
+            candidate_complete = (folder_path / "npz" / COMPLETE_MARKER_NAME).exists()
+            if candidate_complete and not existing_complete:
+                seen[folder_path.name] = folder_path
     for video_id, folder_path in sorted(seen.items()):
         yield video_id, folder_path
 
@@ -50,12 +57,15 @@ def count_complete(home_dataset_dir: Path, scratch_dataset_dir: Path | None = No
 
 def find_dataset_video_dir(video_id: str, home_dataset_dir: Path, scratch_dataset_dir: Path | None = None) -> Path:
     home_path = home_dataset_dir / video_id
+    scratch_path = scratch_dataset_dir / video_id if scratch_dataset_dir is not None else None
+    home_complete = (home_path / "npz" / COMPLETE_MARKER_NAME).exists()
+    scratch_complete = bool(scratch_path is not None and (scratch_path / "npz" / COMPLETE_MARKER_NAME).exists())
+    if scratch_complete and not home_complete:
+        return scratch_path
     if home_path.exists():
         return home_path
-    if scratch_dataset_dir is not None:
-        scratch_path = scratch_dataset_dir / video_id
-        if scratch_path.exists():
-            return scratch_path
+    if scratch_path is not None and scratch_path.exists():
+        return scratch_path
     return home_path
 
 

utils/stats_npz.py

@@ -36,6 +36,48 @@ def _lock_path(stats_path: Path) -> Path:
     return stats_path.with_suffix(stats_path.suffix + ".lock")
 
 
+def processed_complete_counter_path(stats_path: Path) -> Path:
+    return stats_path.parent / "processed_complete.count"
+
+
+def _counter_lock_path(counter_path: Path) -> Path:
+    return counter_path.with_suffix(counter_path.suffix + ".lock")
+
+
+def read_processed_complete_counter(counter_path: Path) -> int:
+    if not counter_path.exists():
+        return 0
+    try:
+        return int(counter_path.read_text(encoding="utf-8").strip() or "0")
+    except Exception:
+        return 0
+
+
+def write_processed_complete_counter(counter_path: Path, value: int) -> int:
+    counter_path.parent.mkdir(parents=True, exist_ok=True)
+    normalized = max(0, int(value))
+    tmp_path = counter_path.parent / f".{counter_path.name}.{os.getpid()}.tmp"
+    try:
+        tmp_path.write_text(f"{normalized}\n", encoding="utf-8")
+        os.replace(tmp_path, counter_path)
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink(missing_ok=True)
+    return normalized
+
+
+def adjust_processed_complete_counter(counter_path: Path, delta: int) -> int:
+    lock_path = _counter_lock_path(counter_path)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+", encoding="utf-8") as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            current = read_processed_complete_counter(counter_path)
+            return write_processed_complete_counter(counter_path, current + int(delta))
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
 def _load_stats_unlocked(stats_path: Path) -> Dict[str, Dict[str, str]]:
     if not stats_path.exists() or stats_path.stat().st_size == 0:
         return {}