add a script to move data files

scripts/manage_dataset_files.py

@@ -0,0 +1,616 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "aiohttp",
+#     "typer>=0.9",
+#     "rich",
+#     "PyYAML",
+# ]
+# ///
+"""Download ColliderML dataset assets and manage README URL updates."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any, List, Sequence
+from urllib.parse import urlparse
+
+import aiohttp
+import typer
+import yaml
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeElapsedColumn,
+    TransferSpeedColumn,
+)
+from rich.table import Table
+
+
+console = Console()
+app = typer.Typer(help="Manage dataset file URLs declared in README front matter.")
+
+
+@dataclass
+class DataFileEntry:
+    config_name: str
+    path: Sequence[str]
+    url: str
+
+    def parsed(self) -> tuple[str, str]:
+        parsed = urlparse(self.url)
+        return parsed.netloc, parsed.path.lstrip("/")
+
+    def relative_path(self) -> Path:
+        netloc, remainder = self.parsed()
+        return Path(netloc) / Path(remainder)
+
+
+@dataclass
+class DownloadResult:
+    entry: DataFileEntry
+    path: Path
+    success: bool
+    skipped: bool
+    error: Exception | None = None
+    order: int = 0
+
+
+@dataclass
+class VerifyResult:
+    entry: DataFileEntry
+    ok: bool
+    status: int | None
+    detail: str = ""
+    order: int = 0
+
+
+def read_front_matter(readme_path: Path) -> tuple[str, str]:
+    text = readme_path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        raise ValueError("README.md does not start with YAML front matter.")
+    try:
+        front_matter, body = text[4:].split("\n---\n", 1)
+    except ValueError as exc:
+        raise ValueError("README.md front matter is not terminated by '---'.") from exc
+    return front_matter, body
+
+
+def load_data_file_entries(front_matter_text: str) -> List[DataFileEntry]:
+    data = yaml.safe_load(front_matter_text)
+    configs = data.get("configs", []) if isinstance(data, dict) else []
+    entries: List[DataFileEntry] = []
+
+    def _walk(value: Any, path: list[str]) -> None:
+        if value is None:
+            return
+        if isinstance(value, str):
+            entries.append(
+                DataFileEntry(config_name=current_config, path=tuple(path), url=value)
+            )
+        elif isinstance(value, list):
+            for idx, item in enumerate(value):
+                _walk(item, [*path, str(idx)])
+        elif isinstance(value, dict):
+            for key, item in value.items():
+                _walk(item, [*path, str(key)])
+
+    for config in configs:
+        if not isinstance(config, dict):
+            continue
+        current_config = str(config.get("config_name", "<unnamed>"))
+        _walk(config.get("data_files"), ["data_files"])
+
+    return entries
+
+
+def replace_once(text: str, old: str, new: str) -> str:
+    index = text.find(old)
+    if index == -1:
+        raise ValueError(f"Value '{old}' was not found in front matter.")
+    return f"{text[:index]}{new}{text[index + len(old):]}"
+
+
+def render_rewrite_template(
+    template: str, result: DownloadResult, output_dir: Path
+) -> str:
+    entry = result.entry
+    netloc, remote_path = entry.parsed()
+    relative_path = result.path.relative_to(output_dir)
+    context = {
+        "config": entry.config_name,
+        "filename": Path(remote_path).name,
+        "stem": Path(remote_path).stem,
+        "netloc": netloc,
+        "remote_path": remote_path,
+        "relative_path": relative_path.as_posix(),
+        "local_path": result.path.as_posix(),
+        "output_dir": output_dir.as_posix(),
+    }
+    try:
+        return template.format(**context)
+    except KeyError as exc:
+        missing = ", ".join(sorted(set(exc.args)))
+        raise typer.BadParameter(f"Template is missing keys: {missing}") from exc
+
+
+def resolve_destination(entry: DataFileEntry, output_dir: Path) -> Path:
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    base_dir = output_dir / entry.config_name
+    return (base_dir / filename).resolve()
+
+
+async def download_one(
+    entry: DataFileEntry,
+    output_dir: Path,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    skip_existing: bool,
+    progress: Progress,
+    order: int,
+) -> DownloadResult:
+    _, remote_path = entry.parsed()
+    filename = Path(remote_path).name or remote_path
+    terse_name = (filename[:32] + "…") if len(filename) > 33 else filename
+    description = f"{entry.config_name}: {terse_name}"
+    async with semaphore:
+        task_id: int | None = None
+        destination = resolve_destination(entry, output_dir)
+        tmp_path = destination.parent / f"{destination.name}.part"
+        try:
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            task_id = progress.add_task(description, total=0, start=False)
+            progress.start_task(task_id)
+            async with session.get(entry.url) as response:
+                response.raise_for_status()
+                total_bytes = response.content_length or 0
+                if (
+                    skip_existing
+                    and destination.exists()
+                    and total_bytes
+                    and destination.stat().st_size == total_bytes
+                ):
+                    if task_id is not None:
+                        progress.remove_task(task_id)
+                        task_id = None
+                    return DownloadResult(
+                        entry=entry,
+                        path=destination,
+                        success=True,
+                        skipped=True,
+                        order=order,
+                    )
+                if total_bytes:
+                    progress.update(task_id, total=total_bytes)
+                with tmp_path.open("wb") as handle:
+                    async for chunk in response.content.iter_chunked(1 << 17):
+                        handle.write(chunk)
+                        progress.update(task_id, advance=len(chunk))
+            tmp_path.rename(destination)
+            return DownloadResult(
+                entry=entry,
+                path=destination,
+                success=True,
+                skipped=False,
+                order=order,
+            )
+        except Exception as exc:  # noqa: BLE001
+            with contextlib.suppress(FileNotFoundError):
+                tmp_path.unlink()
+            return DownloadResult(
+                entry=entry,
+                path=destination,
+                success=False,
+                skipped=False,
+                error=exc,
+                order=order,
+            )
+        finally:
+            if task_id is not None:
+                progress.remove_task(task_id)
+
+
+async def perform_downloads(
+    entries: Sequence[DataFileEntry],
+    output_dir: Path,
+    max_concurrency: int,
+    timeout: float,
+    skip_existing: bool,
+) -> List[DownloadResult]:
+    if not entries:
+        return []
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+    results: List[DownloadResult] = []
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    progress = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(bar_width=None),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            tasks: list[asyncio.Task[DownloadResult]] = []
+            for order, entry in enumerate(entries):
+                task = asyncio.create_task(
+                    download_one(
+                        entry=entry,
+                        output_dir=output_dir,
+                        session=session,
+                        semaphore=semaphore,
+                        skip_existing=skip_existing,
+                        progress=progress,
+                        order=order,
+                    )
+                )
+                tasks.append(task)
+
+            for future in asyncio.as_completed(tasks):
+                result = await future
+                results.append(result)
+
+    results.sort(key=lambda item: item.order)
+    return results
+
+
+async def verify_one(
+    entry: DataFileEntry,
+    session: aiohttp.ClientSession,
+    semaphore: asyncio.Semaphore,
+    order: int,
+) -> VerifyResult:
+    async with semaphore:
+        last_error: str = ""
+        for method in ("HEAD", "GET"):
+            try:
+                async with session.request(
+                    method, entry.url, allow_redirects=True
+                ) as response:
+                    status = response.status
+                    if status < 400:
+                        return VerifyResult(
+                            entry=entry, ok=True, status=status, order=order
+                        )
+                    if method == "HEAD" and status in {405, 501}:
+                        last_error = f"{method} returned {status}; retrying with GET."
+                        continue
+                    return VerifyResult(
+                        entry=entry,
+                        ok=False,
+                        status=status,
+                        detail=f"{method} -> {status}",
+                        order=order,
+                    )
+            except Exception as exc:  # noqa: BLE001
+                last_error = str(exc)
+        return VerifyResult(
+            entry=entry,
+            ok=False,
+            status=None,
+            detail=last_error or "Unknown error",
+            order=order,
+        )
+
+
+async def perform_verification(
+    entries: Sequence[DataFileEntry],
+    max_concurrency: int,
+    timeout: float,
+) -> List[VerifyResult]:
+    if not entries:
+        return []
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+    timeout_cfg = aiohttp.ClientTimeout(total=timeout)
+    results: List[VerifyResult] = []
+    progress = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+    async with aiohttp.ClientSession(timeout=timeout_cfg) as session:
+        with progress:
+            task_id = progress.add_task("Verifying dataset URLs", total=len(entries))
+            tasks = [
+                asyncio.create_task(verify_one(entry, session, semaphore, order=order))
+                for order, entry in enumerate(entries)
+            ]
+            for future in asyncio.as_completed(tasks):
+                result = await future
+                results.append(result)
+                progress.advance(task_id)
+
+    results.sort(key=lambda item: item.order)
+    return results
+
+
+def rewrite_readme(
+    readme_path: Path,
+    front_matter_text: str,
+    body_text: str,
+    results: Sequence[DownloadResult],
+    template: str,
+    output_dir: Path,
+) -> None:
+    updated_front = front_matter_text
+    replacements: list[tuple[DownloadResult, str]] = []
+    for result in results:
+        new_url = render_rewrite_template(template, result, output_dir=output_dir)
+        updated_front = replace_once(updated_front, result.entry.url, new_url)
+        replacements.append((result, new_url))
+
+    readme_path.write_text(f"---\n{updated_front}\n---\n{body_text}", encoding="utf-8")
+
+    table = Table(title="README URL updates")
+    table.add_column("Config")
+    table.add_column("Old URL", overflow="fold")
+    table.add_column("New URL", overflow="fold")
+    for result, new_url in replacements:
+        table.add_row(result.entry.config_name, result.entry.url, new_url)
+    console.print(table)
+
+
+def ensure_all_success(results: Sequence[DownloadResult]) -> bool:
+    return all(result.success for result in results)
+
+
+@app.command()
+def download(
+    output_dir: Annotated[
+        Path,
+        typer.Option(
+            "--output-dir",
+            "-o",
+            help="Directory where files will be stored.",
+            resolve_path=True,
+        ),
+    ],
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum number of concurrent downloads.",
+        ),
+    ] = 4,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 600.0,
+    rewrite_template: Annotated[
+        str | None,
+        typer.Option(
+            "--rewrite-template",
+            help=(
+                "Optional template for rewriting URLs in README. "
+                "Placeholders: {relative_path}, {remote_path}, {filename}, {stem}, {config}, {netloc}, {local_path}, {output_dir}."
+            ),
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run/--no-dry-run",
+            show_default=True,
+            help="Preview downloads and README rewrites without performing any changes.",
+        ),
+    ] = False,
+    skip_existing: Annotated[
+        bool,
+        typer.Option(
+            "--skip-existing/--no-skip-existing",
+            show_default=True,
+            help="Skip downloading files that already exist locally.",
+        ),
+    ] = True,
+) -> None:
+    front_matter_text, body_text = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        console.print(
+            "[yellow]No data_files entries found in README front matter.[/yellow]"
+        )
+        raise typer.Exit(code=0)
+
+    console.print(
+        f"[cyan]Found {len(entries)} data file URLs across {readme_path}.[/cyan]"
+    )
+    output_dir = output_dir.resolve()
+
+    if dry_run:
+        preview = Table(title="Download plan (dry-run)")
+        preview.add_column("Config")
+        preview.add_column("Local file", overflow="fold")
+        preview.add_column("Source URL", overflow="fold")
+        preview.add_column(
+            "Rewritten URL" if rewrite_template else "Rewritten URL (n/a)",
+            overflow="fold",
+        )
+        for order, entry in enumerate(entries):
+            destination = resolve_destination(entry, output_dir)
+            try:
+                relative = destination.relative_to(output_dir)
+            except ValueError:
+                relative = Path(destination)
+            new_url = "-"
+            if rewrite_template:
+                fake_result = DownloadResult(
+                    entry=entry,
+                    path=destination,
+                    success=True,
+                    skipped=False,
+                    order=order,
+                )
+                new_url = render_rewrite_template(
+                    rewrite_template, fake_result, output_dir
+                )
+            preview.add_row(
+                entry.config_name,
+                relative.as_posix(),
+                entry.url,
+                new_url,
+            )
+        console.print(preview)
+        console.print(
+            "[yellow]Dry run: no files downloaded and README left unchanged.[/yellow]"
+        )
+        return
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    results = asyncio.run(
+        perform_downloads(
+            entries=entries,
+            output_dir=output_dir,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+            skip_existing=skip_existing,
+        )
+    )
+
+    successes = sum(1 for item in results if item.success)
+    failures = len(results) - successes
+    skipped = sum(1 for item in results if item.skipped)
+    console.print(
+        f"[green]{successes}[/green] succeeded, [red]{failures}[/red] failed, [yellow]{skipped}[/yellow] skipped."
+    )
+
+    if failures:
+        for item in results:
+            if not item.success:
+                console.print(f"[red]Error:[/red] {item.entry.url} -> {item.error}")
+
+    if rewrite_template:
+        if not ensure_all_success(results):
+            console.print(
+                "[red]README rewrite skipped because some downloads failed.[/red]"
+            )
+            raise typer.Exit(code=1)
+            rewrite_readme(
+                readme_path,
+                front_matter_text,
+                body_text,
+                results,
+                rewrite_template,
+                output_dir=output_dir,
+            )
+        console.print("[green]README.md updated with new URLs.[/green]")
+
+    if failures:
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def verify(
+    readme_path: Annotated[
+        Path,
+        typer.Option(
+            "--readme-path",
+            "-r",
+            help="Path to the README file with YAML front matter.",
+            exists=True,
+            resolve_path=True,
+            dir_okay=False,
+        ),
+    ] = Path("README.md"),
+    max_concurrency: Annotated[
+        int,
+        typer.Option(
+            "--max-concurrency",
+            "-c",
+            min=1,
+            show_default=True,
+            help="Maximum concurrent verification requests.",
+        ),
+    ] = 8,
+    timeout: Annotated[
+        float,
+        typer.Option(
+            "--timeout",
+            min=1.0,
+            show_default=True,
+            help="Request timeout in seconds.",
+        ),
+    ] = 60.0,
+) -> None:
+    front_matter_text, _ = read_front_matter(readme_path)
+    entries = load_data_file_entries(front_matter_text)
+    if not entries:
+        console.print(
+            "[yellow]No data_files entries found in README front matter.[/yellow]"
+        )
+        raise typer.Exit(code=0)
+
+    console.print(f"[cyan]Verifying {len(entries)} URLs from {readme_path}.[/cyan]")
+    results = asyncio.run(
+        perform_verification(
+            entries=entries,
+            max_concurrency=max_concurrency,
+            timeout=timeout,
+        )
+    )
+
+    table = Table(title="URL verification results")
+    table.add_column("Config")
+    table.add_column("Status")
+    table.add_column("Detail", overflow="fold")
+    failed = 0
+    for result in sorted(results, key=lambda r: (not r.ok, r.order)):
+        status_text = str(result.status) if result.status is not None else "-"
+        if result.ok:
+            table.add_row(
+                result.entry.config_name,
+                f"[green]{status_text}[/green]",
+                result.entry.url,
+            )
+        else:
+            failed += 1
+            detail = result.detail or result.entry.url
+            table.add_row(
+                result.entry.config_name,
+                f"[red]{status_text}[/red]",
+                f"{result.entry.url}\n{detail}",
+            )
+
+    console.print(table)
+    if failed:
+        console.print(f"[red]{failed} URLs failed verification.[/red]")
+        raise typer.Exit(code=1)
+    console.print("[green]All URLs verified successfully.[/green]")
+
+
+if __name__ == "__main__":
+    app()