outo-models-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{outo_models_cli-0.2.0 → outo_models_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: outo-models-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Command-line client for self-hosted outo-models servers — auth, repo, download, and upload.
 Project-URL: Homepage, https://github.com/outo-models/outo-models
 Project-URL: Documentation, https://github.com/outo-models/outo-models/blob/main/omc/README.md

{outo_models_cli-0.2.0 → outo_models_cli-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "outo-models-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Command-line client for self-hosted outo-models servers — auth, repo, download, and upload."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{outo_models_cli-0.2.0 → outo_models_cli-0.2.2}/src/outo_models_cli/api/lfs.py

@@ -40,7 +40,7 @@ import hashlib
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Protocol
 
 LFS_CONTENT_TYPE = "application/vnd.git-lfs+json"
 
@@ -104,10 +104,17 @@ class Partition:
     large: list[LargeFile] = field(default_factory=list)
 
 
-def _sha256_of(path: Path) -> tuple[str, int]:
+def _sha256_of(
+    path: Path,
+    *,
+    progress: _ProgressSink | None = None,
+    task_id: Any = None,
+) -> tuple[str, int]:
     """Stream `path` through sha256; return `(hex_digest, size)`.
 
     A 1 MiB read buffer keeps memory bounded regardless of file size.
+    When `progress`/`task_id` are given, hashing advances the task so a
+    multi-GiB file does not sit in silent disk reads for minutes.
     Errors from the underlying `open()` (file removed between the
     partition step and the PUT) surface unchanged so the caller's
     `OmcError` mapping sees the real cause.
@@ -121,10 +128,17 @@ def _sha256_of(path: Path) -> tuple[str, int]:
                 break
             hasher.update(chunk)
             total += len(chunk)
+            if progress is not None and task_id is not None:
+                progress.update(task_id, advance=len(chunk))
     return hasher.hexdigest(), total
 
 
-def partition_files(files: Iterable[Path], *, cap_bytes: int) -> Partition:
+def partition_files(
+    files: Iterable[Path],
+    *,
+    cap_bytes: int,
+    show_progress: bool = True,
+) -> Partition:
     """Split `files` into small (multipart) and large (LFS) buckets.
 
     The function streams each large file exactly once to compute its
@@ -137,24 +151,67 @@ def partition_files(files: Iterable[Path], *, cap_bytes: int) -> Partition:
 
     small: list[Path] = []
     large: list[LargeFile] = []
-    for f in files:
-        size = f.stat().st_size
-        if size <= cap_bytes:
-            small.append(f)
-            continue
-        oid, observed = _sha256_of(f)
-        if observed != size:
-            # Defensive: `stat().st_size` could race with concurrent
-            # writers. Surface as `BadResponseError`-shaped failure so
-            # the user sees a clean English line, not a Python traceback.
-            raise BadResponseError(
-                f"Size of {f} changed during hashing ({observed} != {size}); retry.",
+    hashing: _ProgressSink | None = None
+    try:
+        for f in files:
+            size = f.stat().st_size
+            if size <= cap_bytes:
+                small.append(f)
+                continue
+            if hashing is None and show_progress:
+                hashing = _make_hash_progress()
+            task_id = (
+                hashing.add_task(f"hash {f.name}", total=size) if hashing is not None else None
             )
-        large.append(LargeFile(path=f, oid=oid, size=size))
+            oid, observed = _sha256_of(f, progress=hashing, task_id=task_id)
+            if hashing is not None and task_id is not None:
+                hashing.remove_task(task_id)
+            if observed != size:
+                # Defensive: `stat().st_size` could race with concurrent
+                # writers. Surface as `BadResponseError`-shaped failure so
+                # the user sees a clean English line, not a Python traceback.
+                raise BadResponseError(
+                    f"Size of {f} changed during hashing ({observed} != {size}); retry.",
+                )
+            large.append(LargeFile(path=f, oid=oid, size=size))
+    finally:
+        if hashing is not None:
+            hashing.stop()
     large.sort(key=lambda lf: lf.size, reverse=True)
     return Partition(small=small, large=large)
 
 
+class _ProgressSink(Protocol):
+    """The add/update/remove/stop surface partition_files needs."""
+
+    def add_task(self, description: str, *, total: float | None = None) -> Any: ...
+    def update(self, task_id: Any, **kwargs: Any) -> None: ...
+    def remove_task(self, task_id: Any) -> None: ...
+    def stop(self) -> None: ...
+
+
+def _make_hash_progress() -> _ProgressSink:
+    """A Rich progress dedicated to the hashing phase (file-named tasks)."""
+    from rich.progress import (
+        BarColumn,
+        DownloadColumn,
+        Progress,
+        TextColumn,
+        TimeRemainingColumn,
+        TransferSpeedColumn,
+    )
+
+    progress = Progress(
+        TextColumn("[bold cyan]{task.description}[/bold cyan]", justify="left"),
+        BarColumn(bar_width=40),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+    )
+    progress.start()
+    return progress
+
+
 # ---------------------------------------------------------------------------
 # Deduplication — identical (oid, size) pairs collapse to one batch entry
 # ---------------------------------------------------------------------------

{outo_models_cli-0.2.0 → outo_models_cli-0.2.2}/src/outo_models_cli/api/lfs_upload.py

@@ -26,6 +26,7 @@ from rich.progress import (
     Progress,
     TaskID,
     TextColumn,
+    TimeRemainingColumn,
     TransferSpeedColumn,
 )
 
@@ -83,7 +84,8 @@ def _put_stream(
                 chunk = fp.read(PUT_CHUNK_BYTES)
                 if not chunk:
                     break
-                progress.update(task_id, advance=len(chunk))
+                if progress is not None and task_id is not None:
+                    progress.update(task_id, advance=len(chunk))
                 yield chunk
 
     response = client.put(url, content=_chunk_iter(), headers=headers)
@@ -95,8 +97,17 @@ def _put_stream(
             "Check that the configured PAT matches the account owner.",
         )
     if response.status_code == 413:
+        # Prefer the server's reason: it names the configured limit and the
+        # env var that raises it (field failure: the generic line gave the
+        # operator nothing actionable).
+        detail = ""
+        try:
+            detail = str(response.json().get("error", ""))
+        except ValueError:
+            detail = response.text[:200]
+        suffix = f" ({detail})" if detail else ""
         raise FileTooLargeError(
-            f"LFS object exceeds the server's per-object cap: {path.name}.",
+            f"{path.name} was rejected by the server as too large.{suffix}",
         )
     if response.status_code >= 400:
         raise map_response_error(response)
@@ -108,56 +119,69 @@ def upload_objects(
     actions: list[BatchAction],
     paths_by_oid: dict[str, list[Path]],
     show_progress: bool = True,
+    progress: _ProgressLike | None = None,
 ) -> None:
     """Stream-PUT every `BatchAction` from disk with a Rich progress bar.
 
     `paths_by_oid` maps an oid to its one-or-more source paths; the
     first one is used as the byte source (dedup is exact — same sha256
-    means same bytes). The caller MUST ensure `actions` and
-    `paths_by_oid` agree on the oid set.
+    means same bytes) AND as the human-facing task label — users track
+    "weights-00002-of-00004.safetensors", never a sha prefix. The caller
+    MUST ensure `actions` and `paths_by_oid` agree on the oid set.
+    `progress` lets tests inject a recorder instead of Rich.
     """
     if not actions:
         return
+    # ONE column set for every task row. (The previous layout concatenated
+    # a per-object group and a "total" group, so every row rendered both
+    # groups and the output read as doubled, unlabeled bars.)
     columns: tuple[Any, ...] = (
         TextColumn("[bold blue]{task.description}[/bold blue]", justify="left"),
-        BarColumn(bar_width=40),
-        DownloadColumn(),
-        TransferSpeedColumn(),
-    )
-    overall_columns: tuple[Any, ...] = (
-        TextColumn("[bold green]total[/bold green]"),
-        BarColumn(bar_width=40),
+        BarColumn(bar_width=32),
         DownloadColumn(),
         TransferSpeedColumn(),
+        TimeRemainingColumn(),
     )
     total_bytes = sum(a.size for a in actions)
-    if show_progress:
-        progress_cm: Any = Progress(*columns, *overall_columns, expand=True)
-    else:
-        progress_cm = _NullProgress()
-    with progress_cm as progress:
-        overall = progress.add_task("total", total=total_bytes)
-        for action in actions:
-            sources = paths_by_oid.get(action.oid) or []
-            if not sources:
-                raise BadResponseError(
-                    f"LFS action for oid {action.oid} has no source file on disk.",
-                )
-            task_id = progress.add_task(
-                action.oid[:12],
-                total=action.size,
-            )
-            _put_stream(
-                client,
-                url=action.href,
-                path=sources[0],
-                extra_headers=action.header,
-                progress=progress,
-                task_id=task_id,
+    if progress is not None:
+        _upload_all(
+            progress, client, actions=actions, paths_by_oid=paths_by_oid, total_bytes=total_bytes
+        )
+        return
+    progress_cm: Any = Progress(*columns, expand=True) if show_progress else _NullProgress()
+    with progress_cm as active:
+        _upload_all(
+            active, client, actions=actions, paths_by_oid=paths_by_oid, total_bytes=total_bytes
+        )
+
+
+def _upload_all(
+    progress: Any,
+    client: httpx.Client,
+    *,
+    actions: list[BatchAction],
+    paths_by_oid: dict[str, list[Path]],
+    total_bytes: int,
+) -> None:
+    overall = progress.add_task(f"Total ({len(actions)} object(s))", total=total_bytes)
+    for action in actions:
+        sources = paths_by_oid.get(action.oid) or []
+        if not sources:
+            raise BadResponseError(
+                f"LFS action for oid {action.oid} has no source file on disk.",
             )
-            progress.update(task_id, completed=action.size)
-            progress.update(overall, advance=action.size)
-            progress.remove_task(task_id)
+        task_id = progress.add_task(sources[0].name, total=action.size)
+        _put_stream(
+            client,
+            url=action.href,
+            path=sources[0],
+            extra_headers=action.header,
+            progress=progress,
+            task_id=task_id,
+        )
+        progress.update(task_id, completed=action.size)
+        progress.update(overall, advance=action.size)
+        progress.remove_task(task_id)
 
 
 class _NullProgress:

outo_models_cli-0.2.2/tests/test_lfs_upload.py

@@ -0,0 +1,101 @@
+class _Recorder:
+    """Stand-in progress sink capturing task descriptions for assertions."""
+
+    def __init__(self) -> None:
+        self.descriptions: list[str] = []
+        self.advances: list[int] = []
+        self._next = 0
+
+    def add_task(self, description: str, *, total: float | None = None) -> int:
+        self.descriptions.append(description)
+        self._next += 1
+        return self._next - 1
+
+    def update(self, task_id: int, advance: float = 0, **kwargs: object) -> None:
+        self.advances.append(int(advance))
+
+    def remove_task(self, task_id: int) -> None:
+        return None
+
+
+class TestUploadObjectsLabels:
+    """Users track file NAMES, not sha prefixes (the field complaint)."""
+
+    def test_tasks_are_named_after_files(self, tmp_path, monkeypatch):
+        import httpx
+
+        from outo_models_cli.api.lfs_batch import BatchAction
+        from outo_models_cli.api.lfs_upload import upload_objects
+
+        big = tmp_path / "weights-00001-of-00002.safetensors"
+        big.write_bytes(b"x" * 4096)
+        action = BatchAction(
+            oid="a" * 64, size=big.stat().st_size, href="http://srv/put", header={}
+        )
+        recorder = _Recorder()
+
+        def fake_put(client, **kwargs):
+            pass
+
+        monkeypatch.setattr("outo_models_cli.api.lfs_upload._put_stream", fake_put)
+        client = httpx.Client()
+        try:
+            upload_objects(
+                client,
+                actions=[action],
+                paths_by_oid={action.oid: [big]},
+                show_progress=False,
+                progress=recorder,
+            )
+        finally:
+            client.close()
+        assert "weights-00001-of-00002.safetensors" in recorder.descriptions
+        assert any(d.startswith("Total (1 object") for d in recorder.descriptions)
+
+
+class TestPartitionHashingProgress:
+    def test_show_progress_true_does_not_crash(self, tmp_path):
+        from outo_models_cli.api.lfs import partition_files
+
+        big = tmp_path / "big.bin"
+        big.write_bytes(b"y" * 2048)
+        small = tmp_path / "small.txt"
+        small.write_bytes(b"y")
+        partition = partition_files([big, small], cap_bytes=512, show_progress=True)
+        assert [f.name for f in partition.small] == ["small.txt"]
+        assert partition.large and partition.large[0].path.name == "big.bin"
+
+
+class Test413SurfacesServerReason:
+    def test_put_413_includes_server_detail(self, tmp_path):
+        import httpx
+        import pytest
+
+        from outo_models_cli.api.lfs_upload import _put_stream
+        from outo_models_cli.errors import FileTooLargeError
+
+        big = tmp_path / "shard-00001.safetensors"
+        big.write_bytes(b"z" * 32)
+        transport = httpx.MockTransport(
+            lambda req: httpx.Response(
+                413,
+                json={
+                    "error": (
+                        "object exceeds per-object limit 107374182400 bytes "
+                        "(raise OUTO_LFS_MAX_OBJECT_BYTES ...)"
+                    )
+                },
+            )
+        )
+        client = httpx.Client(transport=transport)
+        with pytest.raises(FileTooLargeError) as excinfo:
+            _put_stream(
+                client,
+                url="http://srv/put",
+                path=big,
+                extra_headers={},
+                progress=None,
+                task_id=None,
+            )
+        assert "shard-00001.safetensors" in str(excinfo.value)
+        assert "OUTO_LFS_MAX_OBJECT_BYTES" in str(excinfo.value)

{outo_models_cli-0.2.0 → outo_models_cli-0.2.2}/uv.lock

@@ -227,7 +227,7 @@ wheels = [
 
 [[package]]
 name = "outo-models-cli"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },