hte-cli 0.2.9__tar.gz → 0.2.11__tar.gz

{hte_cli-0.2.9 → hte_cli-0.2.11}/PKG-INFO

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

{hte_cli-0.2.9 → hte_cli-0.2.11}/pyproject.toml

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

{hte_cli-0.2.9 → hte_cli-0.2.11}/src/hte_cli/cli.py

@@ -310,42 +310,108 @@ def session_join(ctx, session_id: str, force_setup: bool):
                     cached_images.append(img)
                     continue
 
-                # Need to pull - show progress
-                last_status = ["connecting..."]  # Use list for closure mutability
+                # Need to pull - show aggregated progress across all layers
+                import re
+                layer_progress: dict[str, dict] = {}  # layer_id -> {current, total, phase}
+                last_display = [""]
+
+                def parse_size(s: str) -> float:
+                    """Parse size string like '10.5MB' or '1.2GB' to bytes."""
+                    if not s:
+                        return 0
+                    s = s.strip()
+                    multipliers = {"B": 1, "KB": 1024, "MB": 1024**2, "GB": 1024**3}
+                    for suffix, mult in multipliers.items():
+                        if s.upper().endswith(suffix):
+                            try:
+                                return float(s[:-len(suffix)].strip()) * mult
+                            except ValueError:
+                                return 0
+                    try:
+                        return float(s)
+                    except ValueError:
+                        return 0
+
+                def format_size(b: float) -> str:
+                    """Format bytes to human readable."""
+                    if b >= 1024**3:
+                        return f"{b/1024**3:.1f}GB"
+                    elif b >= 1024**2:
+                        return f"{b/1024**2:.0f}MB"
+                    elif b >= 1024:
+                        return f"{b/1024:.0f}KB"
+                    return f"{b:.0f}B"
+
                 with console.status(f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]") as status:
                     def show_progress(image: str, line: str):
-                        # Parse docker pull output for layer progress
-                        # Lines look like: "abc123: Downloading [====>   ] 10MB/50MB"
-                        # Or: "abc123: Extracting [====>   ] 10MB/50MB"
-                        # Or: "abc123: Pull complete", "Digest: sha256:...", "Status: ..."
-                        display_text = None
-                        if ": " in line:
-                            parts = line.split(": ", 1)
-                            if len(parts) == 2:
-                                layer_id = parts[0][-8:]  # Last 8 chars of layer ID
-                                layer_status = parts[1]  # Don't truncate - keep full progress
-                                # Show progress bars for Downloading/Extracting with MB info
-                                if "Downloading" in layer_status or "Extracting" in layer_status:
-                                    # Keep progress: "[====>   ] 10.5MB/50MB"
-                                    display_text = f"{layer_id}: {layer_status[:50]}"
-                                elif "Pull complete" in layer_status:
-                                    display_text = f"{layer_id}: done"
-                                elif "Download complete" in layer_status:
-                                    display_text = f"{layer_id}: download done"
-                                elif "Already exists" in layer_status:
-                                    display_text = f"{layer_id}: cached"
-                                elif "Waiting" in layer_status:
-                                    display_text = f"{layer_id}: waiting"
-                                elif "Verifying" in layer_status:
-                                    display_text = f"{layer_id}: verifying"
-                                else:
-                                    display_text = line[:55]
+                        # Parse: "abc123: Downloading  10.5MB/50MB" or "abc123: Extracting  10MB/50MB"
+                        size_match = re.search(
+                            r"([a-f0-9]+):\s*(Downloading|Extracting)\s+(\d+\.?\d*\s*[kMGT]?B)/(\d+\.?\d*\s*[kMGT]?B)",
+                            line, re.IGNORECASE
+                        )
+                        if size_match:
+                            layer_id = size_match.group(1)
+                            phase = size_match.group(2)
+                            current = parse_size(size_match.group(3))
+                            total = parse_size(size_match.group(4))
+                            layer_progress[layer_id] = {"current": current, "total": total, "phase": phase}
+
+                        # Check for completed layers
+                        complete_match = re.search(r"([a-f0-9]+):\s*(Pull complete|Download complete|Already exists)", line)
+                        if complete_match:
+                            layer_id = complete_match.group(1)
+                            if layer_id in layer_progress:
+                                layer_progress[layer_id]["current"] = layer_progress[layer_id]["total"]
+                                layer_progress[layer_id]["phase"] = "done"
+
+                        # Track waiting layers
+                        waiting_match = re.search(r"([a-f0-9]+):\s*Waiting", line)
+                        if waiting_match:
+                            layer_id = waiting_match.group(1)
+                            if layer_id not in layer_progress:
+                                layer_progress[layer_id] = {"current": 0, "total": 0, "phase": "waiting"}
+
+                        # Aggregate progress
+                        total_current = sum(lp.get("current", 0) for lp in layer_progress.values())
+                        total_size = sum(lp.get("total", 0) for lp in layer_progress.values())
+                        downloading = sum(1 for lp in layer_progress.values() if lp.get("phase") == "Downloading")
+                        extracting = sum(1 for lp in layer_progress.values() if lp.get("phase") == "Extracting")
+                        done_layers = sum(1 for lp in layer_progress.values() if lp.get("phase") == "done")
+                        waiting = sum(1 for lp in layer_progress.values() if lp.get("phase") == "waiting")
+                        total_layers = len(layer_progress)
+
+                        # Only show size progress if we have meaningful data (>1MB)
+                        if total_size > 1024 * 1024:
+                            display = f"{format_size(total_current)}/{format_size(total_size)}"
+                            if downloading > 0:
+                                display += f" ({downloading} downloading"
+                                if extracting > 0:
+                                    display += f", {extracting} extracting"
+                                display += ")"
+                            elif extracting > 0:
+                                display += f" ({extracting} extracting)"
+                        elif total_layers > 0:
+                            # Show layer counts instead
+                            parts = []
+                            if downloading > 0:
+                                parts.append(f"{downloading} downloading")
+                            if extracting > 0:
+                                parts.append(f"{extracting} extracting")
+                            if done_layers > 0:
+                                parts.append(f"{done_layers} done")
+                            if waiting > 0:
+                                parts.append(f"{waiting} waiting")
+                            display = ", ".join(parts) if parts else "starting..."
+                        elif "Pulling" in line:
+                            display = "preparing..."
                         elif line.strip():
-                            display_text = line[:55]
+                            display = line[:40]
+                        else:
+                            return
 
-                        if display_text and display_text != last_status[0]:
-                            last_status[0] = display_text
-                            status.update(f"[yellow]↓[/yellow] {short_name} [dim]{display_text}[/dim]")
+                        if display != last_display[0]:
+                            last_display[0] = display
+                            status.update(f"[yellow]↓[/yellow] {short_name} [dim]{display}[/dim]")
 
                     success = pull_image_with_progress(img, on_progress=show_progress)