labtab 0.1.0__py3-none-any.whl

labtab/commands/auth.py

@@ -0,0 +1,205 @@
+"""``labtab auth`` — login, logout, whoami.
+
+``login`` drives the device-pairing flow in :mod:`labtab.auth` and persists
+the returned API key into the config file. ``logout`` clears that key.
+``whoami`` prints the currently signed-in identity.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import urlsplit, urlunsplit
+
+import typer
+from rich.console import Console
+
+from ..auth import PairingResult, persist_pairing, run_pairing, summarise_identity
+from ..client import LabtabClient
+from ..config import Config
+from ..errors import LabtabError, PairingError
+from ..models import CLIPairStart
+from ..output import (
+    dump_json,
+    print_error,
+    print_info,
+    print_success,
+    render_item,
+)
+
+app = typer.Typer(help="Authenticate this terminal with LabTab.")
+
+
+def _validate_base_url(value: str) -> str:
+    parsed = urlsplit(value)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise typer.BadParameter(
+            "Base URL must include a scheme and host, e.g. https://labtab.app/api/v1.",
+        )
+    return value.rstrip("/")
+
+
+def _replace_host(base_url: str, host: str) -> str:
+    parsed = urlsplit(base_url)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise typer.BadParameter(
+            f"Current base URL is invalid and cannot be rewritten: {base_url}",
+        )
+    if "://" in host or "/" in host:
+        raise typer.BadParameter("`--host` must be a bare hostname, e.g. labtab.io.")
+    return urlunsplit(parsed._replace(netloc=host)).rstrip("/")
+
+
+@app.command("login")
+def login(
+    no_browser: bool = typer.Option(
+        False,
+        "--no-browser",
+        help="Don't try to open the confirmation URL in a browser.",
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Pair this terminal with your LabTab account."""
+
+    config = Config.load()
+    client = LabtabClient.from_config(config)
+    console = Console()
+
+    def _announce(start: CLIPairStart) -> None:
+        if json_mode:
+            return
+        minutes = max(1, int((start.expires_in or 600) // 60))
+        console.print(
+            f"Visit [cyan]{start.confirm_url}[/cyan] to confirm this terminal "
+            f"(code: [bold]{start.pairing_code}[/bold], expires in {minutes} min).",
+        )
+
+    try:
+        if json_mode:
+            result: PairingResult = run_pairing(
+                client, open_browser=not no_browser, on_start=_announce,
+            )
+        else:
+            with console.status("Waiting for browser confirmation…", spinner="dots"):
+                result = run_pairing(
+                    client, open_browser=not no_browser, on_start=_announce,
+                )
+    except PairingError as exc:
+        if json_mode:
+            dump_json({"ok": False, "error": exc.message})
+            raise typer.Exit(code=exc.exit_code) from exc
+        print_error(exc.message)
+        raise typer.Exit(code=exc.exit_code) from exc
+    except LabtabError as exc:
+        if json_mode:
+            dump_json({"ok": False, "error": exc.message})
+            raise typer.Exit(code=exc.exit_code) from exc
+        print_error(exc.message)
+        raise typer.Exit(code=exc.exit_code) from exc
+    finally:
+        client.close()
+
+    persist_pairing(config, result)
+
+    if json_mode:
+        dump_json(
+            {
+                "ok": True,
+                "user_email": result.user_email,
+                "default_lab_slug": result.default_lab_slug,
+            },
+        )
+        return
+
+    email = result.user_email or "your account"
+    print_success(f"Signed in as {email}")
+    if result.default_lab_slug:
+        print_info(f"Default lab: {result.default_lab_slug}")
+
+
+@app.command("logout")
+def logout(
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Remove the stored API key from this machine."""
+
+    config = Config.load()
+    was_signed_in = bool(config.api_key)
+    config.clear_auth()
+    config.save()
+
+    if json_mode:
+        dump_json({"ok": True, "was_signed_in": was_signed_in})
+        return
+    if was_signed_in:
+        print_success("Signed out.")
+    else:
+        print_info("Already signed out.")
+
+
+@app.command("whoami")
+def whoami(
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Show who this terminal is signed in as."""
+
+    config = Config.load()
+    summary = summarise_identity(config)
+
+    if json_mode:
+        dump_json(summary)
+        return
+
+    if not summary["signed_in"]:
+        print_info("Not signed in. Run `labtab auth login`.")
+        raise typer.Exit(code=2)
+
+    render_item(
+        summary,
+        fields=[
+            ("User", "user_email"),
+            ("Default lab", "default_lab_slug"),
+            ("Default lab id", "default_lab_id"),
+            ("API base URL", "base_url"),
+            ("Config file", "config_path"),
+        ],
+        title="Signed in",
+    )
+
+
+@app.command("set-base-url")
+def set_base_url(
+    url: str | None = typer.Argument(
+        None,
+        help="Full API base URL, e.g. https://labtab.io/api/v1.",
+    ),
+    host: str | None = typer.Option(
+        None,
+        "--host",
+        help="Replace only the hostname in the current API base URL.",
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Update the API base URL stored in config."""
+
+    if (url is None) == (host is None):
+        raise typer.BadParameter("Provide either a full URL or `--host`, but not both.")
+
+    config = Config.load()
+    old_base_url = config.base_url
+    new_base_url = _validate_base_url(url) if url is not None else _replace_host(old_base_url, host)
+
+    config.base_url = new_base_url
+    config.save()
+
+    payload = {
+        "ok": True,
+        "old_base_url": old_base_url,
+        "base_url": new_base_url,
+    }
+    if json_mode:
+        dump_json(payload)
+        return
+
+    if new_base_url == old_base_url:
+        print_info(f"API base URL already set to {new_base_url}")
+        return
+    print_success(f"API base URL updated to {new_base_url}")

labtab/commands/export.py

@@ -0,0 +1,238 @@
+"""``labtab export`` — kick off a lab export, poll for status, download.
+
+The flow is:
+
+1. ``POST /labs/<id>/export/`` with ``{format: zip|json}`` returns an
+   ``ExportStatus`` (usually ``pending`` or ``processing``).
+2. Poll ``GET /labs/<id>/export/<export_id>/`` every ``--poll`` seconds
+   until status is ``ready`` (download URL available) or ``failed``.
+3. Stream the signed URL to either ``./labtab-export-<timestamp>.<ext>``
+   or stdout when the user passes ``-`` for the output path.
+
+The progress indicator is a :class:`rich.progress.Progress` bar during
+polling and a spinner during the streaming download.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..client import LabtabClient
+from ..config import Config
+from ..errors import APIError, LabtabError
+from ..models import ExportStatus
+from ..output import dump_json, print_error, print_success
+from ._common import bail, resolve_lab
+
+app = typer.Typer(help="Export a lab's data.", invoke_without_command=True)
+
+DEFAULT_POLL_INTERVAL = 3.0
+DEFAULT_TIMEOUT = 600.0
+
+
+def _resolve_lab_id(config: Config, override: str | None) -> str | int:
+    target = resolve_lab(config, override)
+    if target is None:
+        raise APIError(
+            "No lab selected. Pass --lab <slug> or set default_lab_slug in config.",
+        )
+    return target
+
+
+def _format_extension(fmt: str) -> str:
+    return "zip" if fmt == "zip" else "json"
+
+
+def _default_output(fmt: str) -> Path:
+    stamp = datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
+    return Path.cwd() / f"labtab-export-{stamp}.{_format_extension(fmt)}"
+
+
+def _is_terminal(status: str) -> bool:
+    return status in {"ready", "failed"}
+
+
+def poll_until_ready(
+    client: LabtabClient,
+    *,
+    lab_id: str | int,
+    export_id: str | int,
+    poll_interval: float = DEFAULT_POLL_INTERVAL,
+    timeout: float = DEFAULT_TIMEOUT,
+    on_update: Callable[[ExportStatus], None] | None = None,
+    sleep: Callable[[float], None] = time.sleep,
+    now: Callable[[], float] = time.monotonic,
+) -> ExportStatus:
+    """Poll the export endpoint until it reaches a terminal status.
+
+    Returns the final :class:`ExportStatus`. Raises :class:`APIError` on
+    timeout or if the backend reports ``failed``.
+    """
+
+    deadline = now() + timeout
+    while True:
+        status = client.get_export_status(lab_id=lab_id, export_id=export_id)
+        if on_update is not None:
+            on_update(status)
+        if (status.status or "").lower() == "ready":
+            return status
+        if (status.status or "").lower() == "failed":
+            raise APIError(status.error or "Export failed on the server.")
+        if now() >= deadline:
+            raise APIError("Export timed out waiting for the backend.")
+        sleep(poll_interval)
+
+
+@app.callback(invoke_without_command=True)
+def export(
+    ctx: typer.Context,
+    fmt: str = typer.Option(
+        "zip",
+        "--format",
+        help="Export format — zip or json.",
+        case_sensitive=False,
+    ),
+    lab: str | None = typer.Option(None, "--lab", help="Override the default lab."),
+    output: str | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Destination path. Pass '-' to write to stdout.",
+    ),
+    poll_interval: float = typer.Option(
+        DEFAULT_POLL_INTERVAL,
+        "--poll",
+        help="Seconds between status polls.",
+    ),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT,
+        "--timeout",
+        help="Hard timeout (seconds) for the export.",
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Kick off and download a full lab export."""
+
+    # When used with sub-commands we would want to skip; we don't have any,
+    # so run unconditionally. (``invoke_without_command=True`` still triggers
+    # the callback when no sub-command is given.)
+    if ctx.invoked_subcommand is not None:  # pragma: no cover - defensive
+        return
+
+    fmt = fmt.lower()
+    if fmt not in {"zip", "json"}:
+        print_error(f"Unsupported format '{fmt}'. Use zip or json.")
+        raise typer.Exit(code=2)
+
+    config = Config.load()
+    if not config.api_key:
+        from ..errors import NotAuthenticatedError
+
+        bail(NotAuthenticatedError(), json_mode=json_mode)
+        return
+
+    client = LabtabClient.from_config(config)
+    console = Console()
+
+    try:
+        try:
+            lab_id = _resolve_lab_id(config, lab)
+            pending = client.start_export(lab_id=lab_id, fmt=fmt)
+        except LabtabError as exc:
+            bail(exc, json_mode=json_mode)
+            return
+
+        if json_mode:
+            final = poll_until_ready(
+                client,
+                lab_id=lab_id,
+                export_id=pending.id,
+                poll_interval=poll_interval,
+                timeout=timeout,
+            )
+        else:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[bold]{task.description}"),
+                transient=True,
+                console=console,
+            ) as progress:
+                task = progress.add_task("Preparing export…", total=None)
+
+                def _update(status: ExportStatus) -> None:
+                    progress.update(task, description=f"Export status: {status.status}")
+
+                try:
+                    final = poll_until_ready(
+                        client,
+                        lab_id=lab_id,
+                        export_id=pending.id,
+                        poll_interval=poll_interval,
+                        timeout=timeout,
+                        on_update=_update,
+                    )
+                except LabtabError as exc:
+                    bail(exc, json_mode=json_mode)
+                    return
+
+        if not final.download_url:
+            bail(APIError("Export is ready but no download URL was returned."), json_mode=json_mode)
+            return
+
+        # stream to destination
+        try:
+            bytes_written = _stream_export(client, final.download_url, output, fmt, console, json_mode)
+        except LabtabError as exc:
+            bail(exc, json_mode=json_mode)
+            return
+    finally:
+        client.close()
+
+    if json_mode:
+        dump_json(
+            {
+                "ok": True,
+                "lab_id": lab_id,
+                "export_id": final.id,
+                "bytes": bytes_written,
+                "output": output if output else str(_default_output(fmt)),
+            },
+        )
+        return
+
+    target = output if output == "-" else (output or str(_default_output(fmt)))
+    print_success(f"Wrote {bytes_written} bytes to {target}")
+
+
+def _stream_export(
+    client: LabtabClient,
+    url: str,
+    output: str | None,
+    fmt: str,
+    console: Console,
+    json_mode: bool,
+) -> int:
+    """Stream ``url`` to ``output``. Returns bytes written."""
+
+    if output == "-":
+        # Binary stream on stdout — byte-accurate.
+        return client.stream_to_file(url, sys.stdout.buffer)
+
+    destination = Path(output) if output else _default_output(fmt)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    if json_mode:
+        with destination.open("wb") as fh:
+            return client.stream_to_file(url, fh)
+
+    with console.status(f"Downloading to {destination}…", spinner="dots"):
+        with destination.open("wb") as fh:
+            return client.stream_to_file(url, fh)

labtab/commands/grants.py

@@ -0,0 +1,77 @@
+"""``labtab grants`` — list and show grants."""
+
+from __future__ import annotations
+
+import typer
+
+from ..errors import LabtabError
+from ..output import render_item, render_items
+from ._common import bail, client_session, resolve_lab
+
+app = typer.Typer(help="Browse grants.")
+
+
+@app.command("list")
+def list_grants(
+    status: str | None = typer.Option(None, "--status", help="Filter by grant status."),
+    lab: str | None = typer.Option(None, "--lab", help="Override the default lab."),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """List grants in a lab."""
+
+    with client_session() as (config, client):
+        target_lab = resolve_lab(config, lab)
+        try:
+            grants = client.list_grants(lab=target_lab, status=status)
+        except LabtabError as exc:
+            bail(exc, json_mode=json_mode)
+            return
+
+    render_items(
+        grants,
+        columns=[
+            ("ID", "id"),
+            ("Title", "title"),
+            ("Status", "status"),
+            ("Funder", "funder"),
+            ("Amount", "amount"),
+            ("Starts", "start_date"),
+            ("Ends", "end_date"),
+        ],
+        title="Grants",
+        json_mode=json_mode,
+        empty_message="No grants to show.",
+    )
+
+
+@app.command("show")
+def show_grant(
+    grant_id: str = typer.Argument(..., help="Grant ID or slug."),
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """Show a single grant's details."""
+
+    with client_session() as (_config, client):
+        try:
+            grant = client.get_grant(grant_id)
+        except LabtabError as exc:
+            bail(exc, json_mode=json_mode)
+            return
+
+    render_item(
+        grant,
+        fields=[
+            ("ID", "id"),
+            ("Title", "title"),
+            ("Status", "status"),
+            ("Funder", "funder"),
+            ("Amount", "amount"),
+            ("Currency", "currency"),
+            ("PI", "pi_name"),
+            ("Starts", "start_date"),
+            ("Ends", "end_date"),
+            ("Description", "description"),
+        ],
+        title=f"Grant {grant_id}",
+        json_mode=json_mode,
+    )

labtab/commands/labs.py

@@ -0,0 +1,39 @@
+"""``labtab labs`` — list labs the signed-in user belongs to."""
+
+from __future__ import annotations
+
+import typer
+
+from ..errors import LabtabError
+from ..output import render_items
+from ._common import bail, client_session
+
+app = typer.Typer(help="Work with labs you belong to.")
+
+
+@app.command("list")
+def list_labs(
+    json_mode: bool = typer.Option(False, "--json", help="Output JSON."),
+) -> None:
+    """List labs you have membership in."""
+
+    with client_session() as (_config, client):
+        try:
+            labs = client.list_labs()
+        except LabtabError as exc:
+            bail(exc, json_mode=json_mode)
+            return
+
+    render_items(
+        labs,
+        columns=[
+            ("ID", "id"),
+            ("Slug", "slug"),
+            ("Name", "name"),
+            ("PI", "pi.full_name"),
+            ("Members", "member_count"),
+        ],
+        title="Labs",
+        json_mode=json_mode,
+        empty_message="You are not a member of any labs yet.",
+    )