hte-cli 0.1.21__tar.gz → 0.1.23__tar.gz

{hte_cli-0.1.21 → hte_cli-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.1.21
+Version: 0.1.23
 Summary: Human Time-to-Completion Evaluation CLI
 Project-URL: Homepage, https://github.com/sean-peters-au/lyptus-mono
 Author: Lyptus Research

{hte_cli-0.1.21 → hte_cli-0.1.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hte-cli"
-version = "0.1.21"
+version = "0.1.23"
 description = "Human Time-to-Completion Evaluation CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{hte_cli-0.1.21 → hte_cli-0.1.23}/src/hte_cli/cli.py

@@ -398,72 +398,127 @@ def tasks_run(ctx, task_id: str | None):
 
     # Step 5: Pre-pull Docker images with progress
     from hte_cli.runner import prepull_compose_images, extract_images_from_compose
+    import re
 
     if compose_yaml:
         images = extract_images_from_compose(compose_yaml)
         if images:
             console.print()
-            console.print("[bold]Preparing Docker environment...[/bold]")
-
-            # Track pull state for live display
-            pull_status = {}
-
-            def on_image_start(image: str, idx: int, total: int):
-                pull_status[image] = {"status": "pulling", "line": "Starting..."}
+            console.print(f"[bold]Preparing Docker environment ({len(images)} images)...[/bold]")
+
+            # Track layer progress per image: {layer_id: (status, downloaded_mb, total_mb)}
+            image_layers: dict[str, dict[str, tuple[str, float, float]]] = {}
+
+            def parse_size(size_str: str) -> float:
+                """Parse size string like '1.2MB' or '500kB' to MB."""
+                size_str = size_str.strip().upper()
+                if "GB" in size_str:
+                    return float(size_str.replace("GB", "").strip()) * 1024
+                elif "MB" in size_str:
+                    return float(size_str.replace("MB", "").strip())
+                elif "KB" in size_str:
+                    return float(size_str.replace("KB", "").strip()) / 1024
+                elif "B" in size_str:
+                    return float(size_str.replace("B", "").strip()) / (1024 * 1024)
+                return 0
+
+            def parse_docker_line(line: str) -> tuple[str | None, str, float, float]:
+                """Parse Docker pull output to extract layer ID, status, and sizes.
+
+                Returns: (layer_id, status, downloaded_mb, total_mb)
+                """
+                # Format: "79f742de2855: Downloading [==>] 1.2MB/50MB"
+                # Or: "79f742de2855: Pull complete"
+                match = re.match(r"([a-f0-9]+): (.+)", line)
+                if not match:
+                    return None, "", 0, 0
+
+                layer_id = match.group(1)
+                status_part = match.group(2)
+
+                # Try to extract size info from "Downloading [==>] 1.2MB/50MB"
+                size_match = re.search(r"([\d.]+[kKmMgG]?[bB]?)/([\d.]+[kKmMgG]?[bB])", status_part)
+                if size_match:
+                    downloaded = parse_size(size_match.group(1))
+                    total = parse_size(size_match.group(2))
+                    return layer_id, status_part, downloaded, total
+
+                return layer_id, status_part, 0, 0
+
+            def get_progress_summary(image: str) -> str:
+                """Get a human-readable progress summary for an image with MB counts."""
+                if image not in image_layers or not image_layers[image]:
+                    return "Starting..."
+
+                layers = image_layers[image]
+                total_layers = len(layers)
+                complete = sum(1 for s, _, _ in layers.values() if "complete" in s.lower())
+
+                # Sum up download progress
+                total_downloaded_mb = 0
+                total_size_mb = 0
+                for status, downloaded, total in layers.values():
+                    if "complete" in status.lower():
+                        # Completed layers: use total as both downloaded and total
+                        total_downloaded_mb += total
+                        total_size_mb += total
+                    elif total > 0:
+                        total_downloaded_mb += downloaded
+                        total_size_mb += total
+
+                if complete == total_layers and total_layers > 0:
+                    if total_size_mb > 0:
+                        return f"Done ({total_size_mb:.0f}MB)"
+                    return f"Done ({total_layers} layers)"
+                elif total_size_mb > 0:
+                    return f"{total_downloaded_mb:.0f}MB / {total_size_mb:.0f}MB"
+                elif complete > 0:
+                    return f"Pulling ({complete}/{total_layers} layers)"
+                else:
+                    return f"Preparing ({total_layers} layers)"
 
             def on_image_progress(image: str, line: str):
-                # Update the status line (truncate long lines)
-                display_line = line[:60] + "..." if len(line) > 60 else line
-                pull_status[image] = {"status": "pulling", "line": display_line}
-
-            def on_image_complete(image: str, success: bool, reason: str):
-                if reason == "cached":
-                    pull_status[image] = {"status": "cached", "line": "Using cached image"}
-                elif success:
-                    pull_status[image] = {"status": "done", "line": "Pull complete"}
+                """Track layer-level progress with size info."""
+                if image not in image_layers:
+                    image_layers[image] = {}
+
+                layer_id, status, downloaded, total = parse_docker_line(line)
+                if layer_id:
+                    image_layers[image][layer_id] = (status, downloaded, total)
+
+            # Process images sequentially with clear output
+            results = []
+            for idx, img in enumerate(images, 1):
+                short_name = img.split("/")[-1] if "/" in img else img
+
+                # Check if cached first
+                from hte_cli.runner import check_image_exists_locally, pull_image_with_progress
+
+                if check_image_exists_locally(img):
+                    console.print(f"  [green]✓[/green] {short_name} [dim](cached)[/dim]")
+                    results.append((img, True, "cached"))
+                    continue
+
+                # Need to pull - use Rich Status for live updates
+                image_layers[img] = {}
+
+                with console.status(f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]") as status:
+                    def show_progress(image: str, line: str):
+                        on_image_progress(image, line)
+                        summary = get_progress_summary(image)
+                        status.update(f"[yellow]↓[/yellow] {short_name} [dim]{summary}[/dim]")
+
+                    success = pull_image_with_progress(img, on_progress=show_progress)
+
+                # Final status (printed after status context exits)
+                if success:
+                    console.print(f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]")
+                    results.append((img, True, "pulled"))
                 else:
-                    pull_status[image] = {"status": "failed", "line": "Pull failed"}
-
-            # Show progress for each image
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                TextColumn("[dim]{task.fields[status]}[/dim]"),
-                console=console,
-                transient=False,
-            ) as progress:
-                # Create tasks for each image
-                image_tasks = {}
-                for img in images:
-                    short_name = img.split("/")[-1] if "/" in img else img
-                    image_tasks[img] = progress.add_task(
-                        f"[cyan]{short_name}[/cyan]",
-                        total=None,
-                        status="checking...",
-                    )
-
-                pulled, failed = prepull_compose_images(
-                    compose_yaml,
-                    on_image_start=lambda img, idx, total: progress.update(
-                        image_tasks[img], status="pulling..."
-                    ),
-                    on_image_progress=lambda img, line: progress.update(
-                        image_tasks[img],
-                        status=line[:50] + "..." if len(line) > 50 else line,
-                    ),
-                    on_image_complete=lambda img, ok, reason: progress.update(
-                        image_tasks[img],
-                        status=(
-                            "[green]cached[/green]"
-                            if reason == "cached"
-                            else "[green]ready[/green]"
-                            if ok
-                            else "[red]failed[/red]"
-                        ),
-                        completed=True,
-                    ),
-                )
+                    console.print(f"  [red]✗[/red] {short_name} [dim](failed)[/dim]")
+                    results.append((img, False, "failed"))
 
+            failed = sum(1 for _, ok, _ in results if not ok)
             if failed > 0:
                 console.print(
                     f"[yellow]Warning: {failed} image(s) failed to pull. "