outo-models-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: outo-models-cli
-Version: 0.2.1
+Version: 0.2.3
 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.1 → outo_models_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "outo-models-cli"
-version = "0.2.1"
+version = "0.2.3"
 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.1 → outo_models_cli-0.2.3}/src/outo_models_cli/api/lfs_batch.py

@@ -23,6 +23,7 @@ import httpx
 from outo_models_cli.api import send, unwrap
 from outo_models_cli.api.lfs import LFS_CONTENT_TYPE
 from outo_models_cli.errors import BadResponseError, map_response_error
+from outo_models_cli.http import TIMEOUT_BATCH
 
 
 @dataclass(frozen=True, slots=True)
@@ -72,6 +73,7 @@ def batch_upload(
         f"/{owner}/{name}.git/info/lfs/objects/batch",
         headers={"Accept": LFS_CONTENT_TYPE, "Content-Type": LFS_CONTENT_TYPE},
         json=body,
+        timeout=TIMEOUT_BATCH,
     )
     if response.status_code == 404:
         raise BadResponseError(

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/src/outo_models_cli/api/lfs_upload.py

@@ -37,6 +37,7 @@ from outo_models_cli.errors import (
     FileTooLargeError,
     map_response_error,
 )
+from outo_models_cli.http import TIMEOUT_PUT
 
 
 class _ProgressLike(Protocol):
@@ -84,10 +85,11 @@ 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)
+    response = client.put(url, content=_chunk_iter(), headers=headers, timeout=TIMEOUT_PUT)
     if response.status_code == 404:
         raise BadResponseError("LFS object endpoint returned 404.")
     if response.status_code == 401:
@@ -96,8 +98,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)

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/src/outo_models_cli/api/upload.py

@@ -15,6 +15,7 @@ from outo_models_cli.api import (
     unwrap,
 )
 from outo_models_cli.errors import BadResponseError, map_response_error
+from outo_models_cli.http import TIMEOUT_COMMIT
 
 
 def upload(
@@ -84,6 +85,7 @@ def upload(
             f"/api/repos/{owner}/{name}/upload",
             files=multipart_files,
             data=fields,
+            timeout=TIMEOUT_COMMIT,
         )
         if response.status_code >= 400:
             raise map_response_error(response)

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/src/outo_models_cli/errors.py

@@ -130,12 +130,20 @@ def map_response_error(response: httpx.Response, *, fallback: str | None = None)
 
 
 def map_transport_error(exc: httpx.HTTPError) -> OmcError:
-    """Wrap an `httpx.HTTPError` as `ServerUnreachableError`.
+    """Wrap an `httpx.HTTPError` as a stable, actionable CLI error.
 
-    Used by the API client so transport-layer failures (DNS, refusal,
-    timeouts, TLS) surface with a single stable message instead of leaking
-    the underlying class name into the operator's terminal.
+    Timeouts get their own message (field failure: a slow-but-working
+    server was reported as "cannot reach", sending the operator hunting
+    for outages). A timeout often means the server is STILL processing —
+    retrying a commit can duplicate work, so tell the user to check
+    first.
     """
+    if isinstance(exc, httpx.TimeoutException):
+        return ServerUnreachableError(
+            "The server did not respond in time. It may still be processing — "
+            "verify with `omc ls` before retrying, then use a longer timeout "
+            "if it keeps happening.",
+        )
     return ServerUnreachableError(
         "Cannot reach the server. Check the URL, network, and that the server is running.",
     )

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/src/outo_models_cli/http.py

@@ -19,6 +19,16 @@ import httpx
 # the connection for a few seconds. Anything longer is genuinely hung.
 _TIMEOUT = httpx.Timeout(30.0, connect=5.0)
 
+# Long operations need long read timeouts. A multipart commit after a
+# multi-hundred-GiB LFS session does real server-side work (worktree
+# clone, fetch, quota, audit) that can exceed 30 s — the field failure
+# surfaced as "Cannot reach the server" while the server was alive and
+# working. Writes stay unlimited: the transport buffers, so a slow disk
+# on either side must not abort a 3 GiB PUT mid-stream.
+TIMEOUT_BATCH = httpx.Timeout(120.0, connect=5.0)
+TIMEOUT_COMMIT = httpx.Timeout(600.0, connect=5.0)
+TIMEOUT_PUT = httpx.Timeout(None, connect=10.0, read=900.0)
+
 
 def build_client(
     base_url: str,
@@ -138,6 +148,9 @@ def build_basic_async_client(
 
 
 __all__ = [
+    "TIMEOUT_BATCH",
+    "TIMEOUT_COMMIT",
+    "TIMEOUT_PUT",
     "basic_auth_header",
     "build_async_client",
     "build_basic_async_client",

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/tests/test_errors.py

@@ -105,3 +105,26 @@ def test_every_omc_error_has_stable_code() -> None:
     assert ValidationFailedError.code == "validation_failed"
     assert ServerUnreachableError.code == "server_unreachable"
     assert BadResponseError.code == "bad_response"
+
+
+class TestTimeoutMessageSplit:
+    """A working-but-slow server is NOT 'unreachable' (field failure)."""
+
+    def test_timeout_gets_its_own_message(self):
+        import httpx
+
+        from outo_models_cli.errors import map_transport_error
+
+        exc = httpx.ReadTimeout("took too long")
+        err = map_transport_error(exc)
+        assert "did not respond in time" in str(err)
+        assert "Cannot reach" not in str(err)
+
+    def test_connect_error_keeps_unreachable_message(self):
+        import httpx
+
+        from outo_models_cli.errors import map_transport_error
+
+        exc = httpx.ConnectError("refused")
+        err = map_transport_error(exc)
+        assert "Cannot reach the server" in str(err)

{outo_models_cli-0.2.1 → outo_models_cli-0.2.3}/tests/test_lfs_upload.py

@@ -64,3 +64,38 @@ class TestPartitionHashingProgress:
         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.1 → outo_models_cli-0.2.3}/uv.lock

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