refine script

scripts/manage_dataset_files.py

@@ -14,6 +14,9 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import logging
+import shutil
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated, Any, List, Sequence
@@ -23,6 +26,7 @@ import aiohttp
 import typer
 import yaml
 from rich.console import Console
+from rich.logging import RichHandler
 from rich.progress import (
     BarColumn,
     DownloadColumn,
@@ -37,6 +41,15 @@ from rich.table import Table
 console = Console()
 app = typer.Typer(help="Manage dataset file URLs declared in README front matter.")
 
+# Set up logging with rich handler
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(console=console, show_path=False)],
+)
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class DataFileEntry:
@@ -156,6 +169,7 @@ async def download_one(
     skip_existing: bool,
     progress: Progress,
     order: int,
+    staging_dir: Path | None = None,
 ) -> DownloadResult:
     _, remote_path = entry.parsed()
     filename = Path(remote_path).name or remote_path
@@ -164,37 +178,72 @@ async def download_one(
     async with semaphore:
         task_id: int | None = None
         destination = resolve_destination(entry, output_dir)
-        tmp_path = destination.parent / f"{destination.name}.part"
+
+        # Determine download location (staging or direct)
+        if staging_dir:
+            download_dest = resolve_destination(entry, staging_dir)
+            tmp_path = download_dest.parent / f"{download_dest.name}.part"
+        else:
+            download_dest = destination
+            tmp_path = destination.parent / f"{destination.name}.part"
+
         try:
             destination.parent.mkdir(parents=True, exist_ok=True)
+            download_dest.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,
-                    )
+
+                # Check if we can skip this file
+                if skip_existing and destination.exists():
+                    local_size = destination.stat().st_size
+                    if total_bytes and local_size == total_bytes:
+                        if task_id is not None:
+                            progress.remove_task(task_id)
+                            task_id = None
+                        logger.info(
+                            f"Skipped {destination.name} ({total_bytes:,} bytes) - already exists with correct size"
+                        )
+                        return DownloadResult(
+                            entry=entry,
+                            path=destination,
+                            success=True,
+                            skipped=True,
+                            order=order,
+                        )
+                    else:
+                        # File exists but needs re-download
+                        if not total_bytes:
+                            reason = f"remote size unknown, local size is {local_size:,} bytes"
+                        else:
+                            reason = f"size mismatch (local: {local_size:,} bytes, remote: {total_bytes:,} bytes)"
+                        logger.info(f"Downloading {destination.name} - {reason}")
+                else:
+                    # File doesn't exist or skip_existing is disabled
+                    if not destination.exists():
+                        size_info = f" ({total_bytes:,} bytes)" if total_bytes else ""
+                        logger.info(f"Downloading {destination.name}{size_info} - file not found locally")
+                    else:
+                        size_info = f" ({total_bytes:,} bytes)" if total_bytes else ""
+                        logger.info(f"Downloading {destination.name}{size_info} - skip_existing is disabled")
+
                 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)
+
+            # Move from .part to final location
+            tmp_path.rename(download_dest)
+
+            # If using staging, move from staging to final destination asynchronously
+            if staging_dir:
+                logger.info(f"Moving {download_dest.name} from staging to {destination.parent.name}/")
+                await asyncio.to_thread(shutil.move, str(download_dest), str(destination))
+
             return DownloadResult(
                 entry=entry,
                 path=destination,
@@ -224,45 +273,57 @@ async def perform_downloads(
     max_concurrency: int,
     timeout: float,
     skip_existing: bool,
+    use_staging: bool = False,
 ) -> 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,
-    )
+    with contextlib.ExitStack() as stack:
+        # Create staging directory if needed
+        staging_dir: Path | None = None
+        if use_staging:
+            staging_tmp = stack.enter_context(
+                tempfile.TemporaryDirectory(prefix="dataset_staging_")
+            )
+            staging_dir = Path(staging_tmp)
+            logger.info(f"Using staging directory: {staging_dir}")
+
+        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,
+        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,
+                            staging_dir=staging_dir,
+                        )
                     )
-                )
-                tasks.append(task)
+                    tasks.append(task)
 
-            for future in asyncio.as_completed(tasks):
-                result = await future
-                results.append(result)
+                for future in asyncio.as_completed(tasks):
+                    result = await future
+                    results.append(result)
 
-    results.sort(key=lambda item: item.order)
-    return results
+        results.sort(key=lambda item: item.order)
+        return results
 
 
 async def verify_one(
@@ -436,6 +497,14 @@ def download(
             help="Skip downloading files that already exist locally.",
         ),
     ] = True,
+    use_staging: Annotated[
+        bool,
+        typer.Option(
+            "--stage/--no-stage",
+            show_default=True,
+            help="Download to a temporary staging directory first, then move to final destination.",
+        ),
+    ] = False,
 ) -> None:
     front_matter_text, body_text = read_front_matter(readme_path)
     entries = load_data_file_entries(front_matter_text)
@@ -498,6 +567,7 @@ def download(
             max_concurrency=max_concurrency,
             timeout=timeout,
             skip_existing=skip_existing,
+            use_staging=use_staging,
         )
     )