rahcp 0.1.0__py3-none-any.whl

rahcp/__init__.py

@@ -0,0 +1,7 @@
+"""rahcp — Python SDK for HCP Unified API."""
+
+from __future__ import annotations
+
+from rahcp_client import HCPClient, HCPSettings
+
+__all__ = ["HCPClient", "HCPSettings"]

rahcp/cli/__init__.py

@@ -0,0 +1,3 @@
+"""rahcp-cli — CLI for HCP Unified API."""
+
+from __future__ import annotations

rahcp/cli/_client.py

@@ -0,0 +1,32 @@
+"""Shared client factory — auto-authenticates from config/flags/env."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+if TYPE_CHECKING:
+    from rahcp_client import HCPClient
+
+
+def make_client(ctx: typer.Context) -> HCPClient:
+    """Create an HCPClient from resolved settings.
+
+    Priority: CLI flags > env vars > config file > defaults.
+
+    If username/password are available, the client auto-logs in on __aenter__.
+    Tenant is passed during login so the backend routes to the correct HCP tenant.
+    """
+    from rahcp_client import HCPClient
+
+    return HCPClient(
+        endpoint=ctx.obj["endpoint"],
+        username=ctx.obj.get("username", ""),
+        password=ctx.obj.get("password", ""),
+        tenant=ctx.obj.get("tenant"),
+        verify_ssl=ctx.obj.get("verify_ssl", True),
+        timeout=ctx.obj.get("timeout", 30.0),
+        multipart_threshold=ctx.obj.get("multipart_threshold", 100 * 1024 * 1024),
+        multipart_chunk=ctx.obj.get("multipart_chunk", 64 * 1024 * 1024),
+    )

rahcp/cli/_output.py

@@ -0,0 +1,36 @@
+"""Rich table/JSON formatting helpers."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def print_json(data: Any) -> None:
+    """Print data as formatted JSON."""
+    console.print_json(json.dumps(data, indent=2, default=str))
+
+
+def print_table(
+    rows: list[dict[str, Any]],
+    columns: list[str] | None = None,
+    *,
+    title: str | None = None,
+) -> None:
+    """Print a list of dicts as a Rich table."""
+    if not rows:
+        console.print("[dim]No results.[/dim]")
+        return
+
+    cols = columns or list(rows[0].keys())
+    table = Table(title=title)
+    for col in cols:
+        table.add_column(col)
+    for row in rows:
+        table.add_row(*[str(row.get(c, "")) for c in cols])
+    console.print(table)

rahcp/cli/_run.py

@@ -0,0 +1,27 @@
+"""Shared async runner with error handling."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from collections.abc import Coroutine
+from typing import Any
+
+from rahcp.cli._output import console
+
+
+def run(coro: Coroutine[Any, Any, None]) -> None:
+    """Run an async coroutine with clean error output."""
+    try:
+        asyncio.run(coro)
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except Exception as exc:
+        from rahcp_client.errors import HCPError
+
+        if isinstance(exc, HCPError):
+            label = type(exc).__name__
+            console.print(f"[red]{label}:[/red] {exc.message}")
+        else:
+            console.print(f"[red]Error:[/red] {exc}")
+        sys.exit(1)

rahcp/cli/auth.py

@@ -0,0 +1,40 @@
+"""Auth commands — whoami."""
+
+from __future__ import annotations
+
+import base64
+import json
+
+import typer
+
+from rahcp.cli._client import make_client
+from rahcp.cli._output import console, print_json
+from rahcp.cli._run import run
+
+app = typer.Typer(help="Authentication", no_args_is_help=True)
+
+
+@app.command()
+def whoami(ctx: typer.Context) -> None:
+    """Show current user info by decoding the JWT token."""
+
+    async def _whoami() -> None:
+        async with make_client(ctx) as client:
+            token = client.token
+            if not token:
+                console.print("[red]Not authenticated. Check your config.[/red]")
+                raise typer.Exit(1)
+            try:
+                payload_b64 = token.split(".")[1]
+                payload_b64 += "=" * (4 - len(payload_b64) % 4)
+                payload = json.loads(base64.urlsafe_b64decode(payload_b64))
+            except (IndexError, json.JSONDecodeError, Exception) as exc:
+                console.print(f"[red]Invalid token format:[/red] {exc}")
+                raise typer.Exit(1) from exc
+            if ctx.obj["json"]:
+                print_json(payload)
+            else:
+                console.print(f"User: [bold]{payload.get('sub', '?')}[/bold]")
+                console.print(f"Tenant: {payload.get('tenant', '(system)')}")
+
+    run(_whoami())

rahcp/cli/config.py

@@ -0,0 +1,130 @@
+"""YAML config file with named profiles.
+
+Config file: ~/.rahcp/config.yaml (or --config / RAHCP_CONFIG)
+
+Example::
+
+    default: dev
+
+    profiles:
+      dev:
+        endpoint: http://localhost:8000/api/v1
+        username: admin
+        password: secret
+        tenant: dev-ai
+        verify_ssl: false
+      prod:
+        endpoint: http://localhost:8000/api/v1
+        username: prod-user
+        password: secret
+        tenant: prod-archive
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+log = logging.getLogger(__name__)
+
+CONFIG_DIR = Path.home() / ".rahcp"
+CONFIG_PATH = CONFIG_DIR / "config.yaml"
+
+
+class Profile(BaseModel):
+    """A named connection profile."""
+
+    # Connection
+    endpoint: str = "http://localhost:8000/api/v1"
+    username: str = ""
+    password: str = ""
+    tenant: str = ""
+    verify_ssl: bool = True
+    timeout: float = 30.0
+
+    # Multipart upload
+    multipart_threshold: int = 100 * 1024 * 1024
+    multipart_chunk: int = 64 * 1024 * 1024
+    multipart_concurrency: int = 6
+
+    # Bulk transfer defaults
+    bulk_workers: int = 10
+    bulk_progress_interval: float = 5.0
+    bulk_queue_depth: int = 8
+    bulk_tracker_flush_every: int = 500
+    bulk_tracker_dir: str = ""
+    bulk_tracker_prefix: str = ""
+    bulk_presign_batch_size: int = 200
+    bulk_chunk_size: int = 4 * 1024 * 1024  # 4 MB
+    bulk_stream_threshold: int = 100 * 1024 * 1024  # 100 MB
+
+    # IIIF
+    iiif_url: str = "https://iiifintern-ai.ra.se"
+    iiif_timeout: float = 60.0
+    iiif_query_params: str = "full/max/0/default.jpg"
+    iiif_workers: int = 4
+    iiif_referer: str = ""
+
+    # Transkribus
+    transkribus_url: str = "https://transkribus.eu/TrpServer/rest"
+    transkribus_username: str = ""
+    transkribus_password: str = ""
+    transkribus_timeout: float = 60.0
+    transkribus_workers: int = 8
+
+    # Observability
+    log_level: str = "warning"
+    otel_endpoint: str = ""
+    otel_protocol: str = "http/protobuf"
+    otel_service_name: str = "rahcp-cli"
+
+
+class CLIConfig(BaseModel):
+    """Config with named profiles."""
+
+    default: str = ""
+    profiles: dict[str, Profile] = Field(default_factory=dict)
+
+    def resolve(self, name: str | None = None) -> Profile:
+        """Resolve a profile by name, falling back to default."""
+        key = name or self.default
+        if key and key in self.profiles:
+            return self.profiles[key]
+        if len(self.profiles) == 1:
+            return next(iter(self.profiles.values()))
+        return Profile()
+
+
+def load_config(path: str | None = None) -> CLIConfig:
+    """Load config from a YAML file.
+
+    Resolution: explicit path > RAHCP_CONFIG env > ~/.rahcp/config.yaml
+    """
+    config_path = Path(path) if path else CONFIG_PATH
+    if not config_path.exists():
+        return CLIConfig()
+    try:
+        raw = yaml.safe_load(config_path.read_text()) or {}
+    except Exception:
+        log.warning("Failed to parse config file: %s", config_path)
+        return CLIConfig()
+
+    # Multi-profile format
+    if "profiles" in raw:
+        return CLIConfig(
+            default=raw.get("default", ""),
+            profiles={
+                name: Profile(**vals)
+                for name, vals in raw["profiles"].items()
+                if isinstance(vals, dict)
+            },
+        )
+
+    # Flat format (backwards compat) — single "default" profile
+    return CLIConfig(
+        default="default",
+        profiles={"default": Profile(**raw)},
+    )