outo-models-cli 0.1.0__py3-none-any.whl

outo_models_cli/commands/_shared.py

@@ -0,0 +1,173 @@
+"""Shared helpers for the `omc` Typer commands.
+
+This module owns:
+
+    * the standard consoles (`console`, `err_console`) every command uses,
+    * the byte-size and visibility helpers,
+    * the `owner/name` parser,
+    * the `Store → (base_url, httpx.Client)` resolver,
+    * the local-path collector used by `upload`.
+
+The Typer `app` and command registration live in `main.py`. Concentrating
+    the shared infrastructure here keeps each command module under the
+    250-LOC ceiling without scattering the error contract across files.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import httpx
+from rich.console import Console
+
+from outo_models_cli import api
+from outo_models_cli.errors import (
+    FileMissingError,
+    FileTooLargeError,
+    OmcError,
+)
+
+if TYPE_CHECKING:
+    from outo_models_cli.config import Store
+
+# 100 MiB per-file cap mirrors the server's multipart boundary. Anything
+# larger must be uploaded via git + LFS.
+_MAX_FILE_BYTES = 100 * 1024 * 1024
+
+# 50 MiB total upload cap before the CLI auto-batches per-file. Anything
+# smaller goes up in one multipart request.
+_SINGLE_REQUEST_TOTAL_BYTES = 50 * 1024 * 1024
+
+_VALID_KINDS = ("model", "dataset", "space")
+
+
+# ---------------------------------------------------------------------------
+# Consoles
+# ---------------------------------------------------------------------------
+
+console = Console(stderr=False)
+err_console = Console(stderr=True)
+
+
+def _errprint(message: str) -> None:
+    """Print a single-line message to stderr."""
+    err_console.print(f"[bold red]error[/bold red]: {message}")
+
+
+# ---------------------------------------------------------------------------
+# Validators
+# ---------------------------------------------------------------------------
+
+
+def _validate_kind(raw: str) -> str:
+    """Return `raw` if it's a known repo kind, else raise `OmcError`."""
+    if raw not in _VALID_KINDS:
+        valid = ", ".join(_VALID_KINDS)
+        raise OmcError(f"Invalid kind {raw!r}. Use one of: {valid}.")
+    return raw
+
+
+def _visibility(public: bool, private: bool) -> str:
+    """Resolve the two-flag visibility pair into a single keyword."""
+    if public and private:
+        raise OmcError("Pass only one of --public / --private.")
+    if public:
+        return "public"
+    if private:
+        return "private"
+    return "private"  # default matches the server's default
+
+
+def _parse_owner_repo(raw: str) -> tuple[str, str]:
+    """Split `owner/name` into `(owner, name)`; raise on malformed input."""
+    if "/" not in raw or raw.count("/") > 1:
+        raise OmcError("Argument must be in the form `<owner>/<name>`.")
+    owner, name = raw.split("/", 1)
+    if not owner or not name:
+        raise OmcError(
+            "Argument must be in the form `<owner>/<name>` (both parts required).",
+        )
+    return owner, name
+
+
+# ---------------------------------------------------------------------------
+# Server resolution
+# ---------------------------------------------------------------------------
+
+
+def _resolve_target(store: Store, *, server: str | None) -> tuple[str, httpx.Client]:
+    """Return `(base_url, httpx.Client)` for the requested target.
+
+    The CLI uses a short-lived client per command so a failed auth does
+    not poison subsequent calls. Token resolution happens inside
+    `store.resolve` (env var → stored entry).
+    """
+    base_url, token = store.resolve(server)
+    return base_url, api.with_client(base_url, token)
+
+
+# ---------------------------------------------------------------------------
+# Upload helpers
+# ---------------------------------------------------------------------------
+
+
+def _collect_files(path: Path) -> tuple[list[Path], Path]:
+    """Return `(file_paths, file_root)` from a user-supplied file or folder."""
+    if not path.exists():
+        raise FileMissingError(f"Local path does not exist: {path}")
+    if path.is_file():
+        return [path], path.parent
+    if path.is_dir():
+        files = [p for p in path.rglob("*") if p.is_file()]
+        if not files:
+            raise OmcError(f"No files found under {path}.")
+        return files, path
+    raise FileMissingError(f"Not a file or directory: {path}")
+
+
+def _check_size_limit(files: Iterable[Path]) -> None:
+    """Raise `FileTooLargeError` if any single file exceeds the per-file cap."""
+    for fpath in files:
+        if fpath.stat().st_size > _MAX_FILE_BYTES:
+            size_mib = fpath.stat().st_size / (1024 * 1024)
+            raise FileTooLargeError(
+                f"{fpath} is {size_mib:.1f} MiB. Files over 100 MiB must be uploaded "
+                "via git + LFS. See `git lfs track` and the server's LFS guide.",
+            )
+
+
+def _human_bytes(num: int) -> str:
+    """Render byte counts in the operator-facing summary line."""
+    units = ("B", "KiB", "MiB", "GiB", "TiB")
+    value = float(num)
+    idx = 0
+    while value >= 1024 and idx < len(units) - 1:
+        value /= 1024
+        idx += 1
+    if idx == 0:
+        return f"{int(value)} {units[idx]}"
+    return f"{value:.2f} {units[idx]}"
+
+
+__all__ = [
+    "_MAX_FILE_BYTES",
+    "_SINGLE_REQUEST_TOTAL_BYTES",
+    "_VALID_KINDS",
+    "_check_size_limit",
+    "_collect_files",
+    "_errprint",
+    "_human_bytes",
+    "_parse_owner_repo",
+    "_resolve_target",
+    "_validate_kind",
+    "_visibility",
+    "console",
+    "err_console",
+]
+
+# `os` is used implicitly through `os.environ` callers in `commands.auth`,
+# but the import here documents the dependency for readers / linters.
+_ = os

outo_models_cli/commands/auth.py

@@ -0,0 +1,196 @@
+"""`omc auth ...` — manage stored credentials.
+
+Four subcommands mirror the HF CLI surface:
+
+    * `login --server <url> [--token PAT] [--set-default]`
+    * `logout [--server <url>]`
+    * `whoami [--server <url>]`
+    * `status`
+
+All four share the `_auth_resolve` helper, which handles URL
+normalization and the env-var overrides the store layer exposes.
+"""
+
+from __future__ import annotations
+
+import getpass
+import os
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.table import Table
+
+from outo_models_cli import api, config
+from outo_models_cli.commands._shared import (
+    _errprint,
+    console,
+)
+from outo_models_cli.errors import (
+    AuthInvalidError,
+    AuthRequiredError,
+    ConfigError,
+    OmcError,
+)
+
+if TYPE_CHECKING:
+    from outo_models_cli.config import Store
+
+auth_app = typer.Typer(help="Manage stored credentials.", no_args_is_help=True)
+
+
+def _prompt_token(url: str) -> str:
+    """Prompt for a PAT (masked) on the controlling terminal."""
+    return getpass.getpass(f"Token for {url}: ")
+
+
+def _resolve_target_url(
+    store: Store,
+    *,
+    requested: str | None,
+) -> str:
+    """Normalize and validate the user-supplied server URL.
+
+    Falls back to the env override (`OMC_SERVER`) and then the configured
+    default so `omc auth logout` without `--server` operates on the
+    current target.
+    """
+    raw = requested or os.environ.get("OMC_SERVER") or store.default_server
+    if not raw:
+        raise AuthRequiredError(
+            "No server given. Pass --server <url> or run `omc auth login --server <url>` first.",
+        )
+    return config.normalize_server_url(raw)
+
+
+@auth_app.command("login")
+def auth_login(
+    ctx: typer.Context,
+    server: Annotated[
+        str | None,
+        typer.Option(help="Server URL (default: pick the first configured server)."),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="PAT to store verbatim (skips the masked prompt). Use only in scripts.",
+        ),
+    ] = None,
+    set_default: Annotated[
+        bool,
+        typer.Option(
+            "--set-default",
+            help="Pin this server as the default target after login.",
+        ),
+    ] = False,
+) -> None:
+    """Log in to a server: verify the PAT and store it."""
+    store: Store = ctx.obj["store"]
+    try:
+        url = _resolve_target_url(store, requested=server)
+    except (OmcError, AuthRequiredError, ConfigError) as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    pat = token or _prompt_token(url)
+    if not pat:
+        _errprint("Empty token; aborting.")
+        raise typer.Exit(code=1)
+
+    # Verify before persisting — a wrong token must never end up on disk.
+    try:
+        with api.with_client(url, pat) as client:
+            identity = api.me(client)
+    except AuthInvalidError:
+        _errprint("Server rejected the token. Re-run with a valid PAT.")
+        raise typer.Exit(code=1) from None
+    except OmcError as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    new_store = store.with_login(url, pat)
+    if set_default:
+        new_store = new_store.with_default(url)
+    config.save_store(new_store, ctx.obj["config_path"])
+
+    source = "OMC_TOKEN env var" if os.environ.get("OMC_TOKEN") == pat else "stored credential"
+    console.print(
+        f"Logged in to {url} as [bold]{identity.username}[/bold] (role: {identity.role}); "
+        f"token source: {source}.",
+    )
+
+
+@auth_app.command("logout")
+def auth_logout(
+    ctx: typer.Context,
+    server: Annotated[
+        str | None,
+        typer.Option(help="Server to log out (default: the configured default)."),
+    ] = None,
+) -> None:
+    """Remove the stored credential for one server."""
+    store: Store = ctx.obj["store"]
+    try:
+        url = _resolve_target_url(store, requested=server)
+    except (OmcError, AuthRequiredError, ConfigError) as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    if url not in store.servers:
+        _errprint(f"No stored credential for {url}.")
+        raise typer.Exit(code=1)
+
+    new_store = store.without(url)
+    config.save_store(new_store, ctx.obj["config_path"])
+    console.print(f"Removed stored credential for {url}.")
+
+
+@auth_app.command("whoami")
+def auth_whoami(
+    ctx: typer.Context,
+    server: Annotated[
+        str | None,
+        typer.Option(help="Server to query (default: the configured default)."),
+    ] = None,
+) -> None:
+    """Print the authenticated user, server, and token source."""
+    store: Store = ctx.obj["store"]
+    try:
+        url, token = store.resolve(server)
+    except AuthRequiredError as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    try:
+        with api.with_client(url, token) as client:
+            identity = api.me(client)
+    except OmcError as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    source = "OMC_TOKEN env var" if os.environ.get("OMC_TOKEN") else "stored credential"
+    table = Table(show_header=False, box=None)
+    table.add_row("server", url)
+    table.add_row("username", identity.username)
+    table.add_row("role", identity.role)
+    table.add_row("token source", source)
+    console.print(table)
+
+
+@auth_app.command("status")
+def auth_status(ctx: typer.Context) -> None:
+    """List every configured server and mark the default."""
+    store: Store = ctx.obj["store"]
+    if not store.servers:
+        console.print("No servers configured. Run `omc auth login --server <url>`.")
+        return
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Server")
+    table.add_column("Default")
+    for url in store.list_servers():
+        is_default = "yes" if url == store.default_server else ""
+        table.add_row(url, is_default)
+    console.print(table)
+
+
+__all__ = ["auth_app"]

outo_models_cli/commands/download.py

@@ -0,0 +1,101 @@
+"""`omc download <owner>/<name>` — recursive, resumable repo download."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+
+from outo_models_cli import downloader
+from outo_models_cli.commands._shared import (
+    _errprint,
+    _human_bytes,
+    _parse_owner_repo,
+    console,
+)
+from outo_models_cli.errors import (
+    AuthRequiredError,
+    OmcError,
+)
+from outo_models_cli.http import build_async_client
+
+if TYPE_CHECKING:
+    from outo_models_cli.config import Store
+
+
+def download_command(
+    ctx: typer.Context,
+    repo: Annotated[str, typer.Argument(help="Repository as `<owner>/<name>`.")],
+    revision: Annotated[
+        str,
+        typer.Option(help="Branch, tag, or commit SHA (default: main)."),
+    ] = "main",
+    include: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--include",
+            help="Glob of paths to include (repeatable). Defaults to everything.",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--exclude",
+            help="Glob of paths to exclude (repeatable). Defaults to nothing.",
+        ),
+    ] = None,
+    local_dir: Annotated[
+        Path,
+        typer.Option(help="Destination directory (default: ./<repo>)."),
+    ] = Path("."),
+    max_workers: Annotated[
+        int,
+        typer.Option(help="Parallel download workers (default: 8)."),
+    ] = 8,
+    server: Annotated[str | None, typer.Option(help="Target server URL.")] = None,
+) -> None:
+    """Recursively download a repository to `--local-dir`."""
+    store: Store = ctx.obj["store"]
+    try:
+        owner, name = _parse_owner_repo(repo)
+        base_url, token = store.resolve(server)
+    except (OmcError, AuthRequiredError) as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    target_dir = local_dir if local_dir != Path(".") else Path(name)
+    cfg = downloader.DownloadConfig(
+        revision=revision,
+        include=include or [],
+        exclude=exclude or [],
+        local_dir=target_dir,
+        max_workers=max_workers,
+    )
+
+    client = build_async_client(base_url, token)
+    try:
+        outcomes = asyncio.run(
+            downloader.download_repo(
+                client=client,
+                base_url=base_url,
+                token=token,
+                owner=owner,
+                name=name,
+                config=cfg,
+            )
+        )
+    except OmcError as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    total_bytes = sum(o.bytes_downloaded for o in outcomes)
+    resumed = sum(1 for o in outcomes if o.resumed)
+    console.print(
+        f"Downloaded {len(outcomes)} file(s) ({_human_bytes(total_bytes)}) to {target_dir}. "
+        f"Resumed: {resumed}.",
+    )
+
+
+__all__ = ["download_command"]

outo_models_cli/commands/ls.py

@@ -0,0 +1,82 @@
+"""`omc ls <owner>/<name>` — list one directory of a repository."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.table import Table
+
+from outo_models_cli import api
+from outo_models_cli.commands._shared import (
+    _errprint,
+    _human_bytes,
+    _parse_owner_repo,
+    _resolve_target,
+    console,
+)
+from outo_models_cli.errors import (
+    AuthRequiredError,
+    OmcError,
+)
+
+if TYPE_CHECKING:
+    from outo_models_cli.config import Store
+
+
+def ls_command(
+    ctx: typer.Context,
+    repo: Annotated[str, typer.Argument(help="Repository as `<owner>/<name>`.")],
+    path: Annotated[
+        str,
+        typer.Option(help="Directory inside the repo to list (default: root)."),
+    ] = "",
+    revision: Annotated[
+        str,
+        typer.Option(help="Branch, tag, or commit SHA (default: main)."),
+    ] = "main",
+    server: Annotated[str | None, typer.Option(help="Target server URL.")] = None,
+) -> None:
+    """List one directory of a repository."""
+    store: Store = ctx.obj["store"]
+    try:
+        owner, name = _parse_owner_repo(repo)
+        _base_url, client = _resolve_target(store, server=server)
+    except (OmcError, AuthRequiredError) as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    try:
+        with client:
+            rows = api.list_files(
+                client,
+                owner=owner,
+                name=name,
+                path=path,
+                revision=revision,
+            )
+    except OmcError as exc:
+        _errprint(str(exc))
+        raise typer.Exit(code=1) from exc
+
+    if not rows:
+        console.print("(empty directory)")
+        return
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Name")
+    table.add_column("Kind")
+    table.add_column("Size")
+    for entry in rows:
+        if entry.kind == "dir":
+            size = "-"
+        elif entry.size_bytes is None:
+            size = "?"
+        elif entry.size_bytes == 0:
+            size = "0 B"
+        else:
+            size = _human_bytes(entry.size_bytes)
+        table.add_row(entry.name, entry.kind, size)
+    console.print(table)
+
+
+__all__ = ["ls_command"]