tamarind-cli 0.1.0__py3-none-any.whl

tamarind/__init__.py

@@ -0,0 +1,16 @@
+"""Tamarind Bio CLI and Python client.
+
+This package is a thin client over the Tamarind platform. Two surfaces:
+
+- REST passthrough (``tamarind.rest``): submit/validate/batch, jobs, result,
+  files, cancel, delete — these hit the Tamarind API directly with an API key.
+  The request/response contract is the same OpenAPI spec the Tamarind MCP server
+  is built from, so the CLI and the MCP cannot drift on this surface.
+
+- Discovery (``tamarind.catalog``): tools, schema, modalities, functions. The
+  catalog lives behind per-org visibility logic that runs server-side, so the
+  CLI consumes it over HTTP (the ``/catalog/*`` routes) rather than reading the
+  database directly.
+"""
+
+__version__ = "0.1.0"

tamarind/catalog.py

@@ -0,0 +1,70 @@
+"""Discovery / catalog client.
+
+The tool catalog and per-tool schemas are gated by per-org visibility logic
+that runs server-side, so the CLI consumes them over HTTP from the catalog
+service (the ``/catalog/*`` routes) rather than reading the database directly.
+
+These routes return exactly the JSON the MCP's discovery tools return
+(``getAvailableTools``, ``listModalities``, ``listTags``, ``getJobSchema``),
+because both are served by the same shared implementation. So whatever a tool
+looks like in the MCP, it looks identical here.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .http import HTTPClient
+
+CATALOG_PREFIX = "catalog"
+
+
+def list_tools(
+    client: HTTPClient,
+    *,
+    modality: str | None = None,
+    function: str | None = None,
+    search: str | None = None,
+    custom: bool | None = None,
+) -> dict:
+    """GET /catalog/tools — the filtered tool catalog (mirrors getAvailableTools)."""
+    params = {
+        "modality": modality,
+        "function": function,
+        "search": search,
+        "custom": "true" if custom else None,
+    }
+    return client.get_json(f"{CATALOG_PREFIX}/tools", params=params)
+
+
+def list_modalities(client: HTTPClient) -> dict:
+    """GET /catalog/modalities — molecule types you can filter by."""
+    return client.get_json(f"{CATALOG_PREFIX}/modalities")
+
+
+def list_functions(client: HTTPClient) -> dict:
+    """GET /catalog/functions — functions (tags) you can filter by."""
+    return client.get_json(f"{CATALOG_PREFIX}/functions")
+
+
+def get_schema(client: HTTPClient, job_type: str) -> dict:
+    """GET /catalog/tools/{jobType}/schema — full parameter schema + example job."""
+    return client.get_json(f"{CATALOG_PREFIX}/tools/{job_type}/schema")
+
+
+# -- helpers for rendering / example extraction ---------------------------
+
+
+def example_settings(schema: dict[str, Any]) -> dict[str, Any]:
+    """Pull a runnable ``settings`` dict out of a schema's exampleJob, if present."""
+    example = schema.get("exampleJob") or {}
+    return dict(example.get("settings") or {})
+
+
+def required_param_names(schema: dict[str, Any]) -> list[str]:
+    """Names of parameters marked required (top-level; ignores task-gated ones)."""
+    out = []
+    for p in schema.get("parameters", []):
+        if p.get("required") and p.get("name"):
+            out.append(p["name"])
+    return out

tamarind/cli/__init__.py

@@ -0,0 +1 @@
+"""Typer command-line interface for Tamarind."""

tamarind/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command groups."""

tamarind/cli/commands/auth.py

@@ -0,0 +1,90 @@
+"""`tamarind auth` — credential management."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ... import rest
+from ...config import mask_key, save_profile
+from ...errors import AuthError
+from ...http import HTTPClient
+from .. import output
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _check_key(api_base: str, api_key: str) -> bool:
+    """Return True if the key authenticates against the job API."""
+    with HTTPClient(api_base, api_key) as client:
+        try:
+            rest.get_jobs(client, limit=1)
+            return True
+        except AuthError:
+            return False
+
+
+@app.command()
+def login(
+    ctx: typer.Context,
+    api_key: Optional[str] = typer.Option(
+        None, "--api-key", help="API key. If omitted, you'll be prompted.", show_default=False
+    ),
+    no_verify: bool = typer.Option(False, "--no-verify", help="Skip verifying the key."),
+) -> None:
+    """Store an API key in the current profile (~/.tamarind/config.json).
+
+    Get a key from https://app.tamarind.bio (Settings → API), or set
+    TAMARIND_API_KEY in the environment to skip storing one.
+    """
+    state = ctx.obj
+    cfg = state.config()
+    key = api_key or typer.prompt("Tamarind API key", hide_input=True)
+    key = key.strip()
+
+    if not no_verify and not _check_key(cfg.api_base, key):
+        raise AuthError("That API key was rejected by the API. Not saved.")
+
+    save_profile(cfg.profile, api_key=key)
+    output.emit(
+        {"ok": True, "profile": cfg.profile, "verified": not no_verify},
+        state.output,
+        human=f"Saved API key to profile '{cfg.profile}'.",
+    )
+
+
+@app.command()
+def status(ctx: typer.Context) -> None:
+    """Show the active profile, endpoints, and whether the key works."""
+    state = ctx.obj
+    cfg = state.config()
+    verified = cfg.has_key and _check_key(cfg.api_base, cfg.api_key)
+    result = {
+        "profile": cfg.profile,
+        "apiKey": mask_key(cfg.api_key),
+        "hasKey": cfg.has_key,
+        "verified": verified,
+        "apiBase": cfg.api_base,
+        "catalogBase": cfg.catalog_base,
+    }
+    human = (
+        f"profile:      {cfg.profile}\n"
+        f"api key:      {mask_key(cfg.api_key)} ({'verified' if verified else 'not verified'})\n"
+        f"job api:      {cfg.api_base}\n"
+        f"catalog api:  {cfg.catalog_base}"
+    )
+    output.emit(result, state.output, human=human)
+
+
+@app.command()
+def logout(ctx: typer.Context) -> None:
+    """Remove the stored API key from the current profile."""
+    state = ctx.obj
+    cfg = state.config()
+    save_profile(cfg.profile, api_key="", make_current=False)
+    output.emit(
+        {"ok": True, "profile": cfg.profile},
+        state.output,
+        human=f"Cleared API key for profile '{cfg.profile}'.",
+    )

tamarind/cli/commands/catalog.py

@@ -0,0 +1,114 @@
+"""Discovery commands: `tamarind tools|modalities|functions|schema`."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ... import catalog
+from .. import output
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def tools(
+        ctx: typer.Context,
+        modality: Optional[str] = typer.Option(None, "--modality", "-m", help="Filter by molecule type (see `tamarind modalities`)."),
+        function: Optional[str] = typer.Option(None, "--function", "-f", help="Filter by function/tag (see `tamarind functions`)."),
+        search: Optional[str] = typer.Option(None, "--search", "-s", help="Free-text search in name/description."),
+        custom: bool = typer.Option(False, "--custom", help="Show only your org's custom tools."),
+    ) -> None:
+        """List available tools. Filter to narrow the (large) catalog."""
+        state = ctx.obj
+        with state.catalog_client() as client:
+            resp = catalog.list_tools(
+                client, modality=modality, function=function, search=search, custom=custom or None
+            )
+        rows = [
+            {
+                "name": t.get("name"),
+                "displayName": t.get("displayName"),
+                "modalities": ",".join(t.get("categories", []) or []),
+            }
+            for t in resp.get("tools", [])
+        ]
+        human = (
+            output.render_table(rows, ["name", "displayName", "modalities"])
+            + f"\n\n{resp.get('totalTools', len(rows))} tools. "
+            "Use `tamarind schema <name>` for parameters."
+        )
+        output.emit(resp, state.output, human=human)
+
+    @app.command()
+    def modalities(ctx: typer.Context) -> None:
+        """List molecule types (modalities) you can filter tools by."""
+        state = ctx.obj
+        with state.catalog_client() as client:
+            resp = catalog.list_modalities(client)
+        rows = [
+            {"value": m.get("value"), "label": m.get("label"), "tools": m.get("toolCount")}
+            for m in resp.get("modalities", [])
+        ]
+        output.emit(resp, state.output, human=output.render_table(rows, ["value", "label", "tools"]))
+
+    @app.command()
+    def functions(ctx: typer.Context) -> None:
+        """List functions (tags) you can filter tools by."""
+        state = ctx.obj
+        with state.catalog_client() as client:
+            resp = catalog.list_functions(client)
+        rows = [
+            {"value": f.get("value"), "label": f.get("label"), "tools": f.get("toolCount")}
+            for f in resp.get("functions", [])
+        ]
+        output.emit(resp, state.output, human=output.render_table(rows, ["value", "label", "tools"]))
+
+    @app.command()
+    def schema(
+        ctx: typer.Context,
+        tool: str = typer.Argument(..., help="Tool name (lowercase, e.g. 'boltz')."),
+        example: bool = typer.Option(False, "--example", help="Print only the runnable example settings (YAML)."),
+    ) -> None:
+        """Show a tool's parameters and a runnable example job."""
+        state = ctx.obj
+        with state.catalog_client() as client:
+            resp = catalog.get_schema(client, tool)
+        # The catalog returns HTTP 200 with {"error": ...} for an unknown/hidden
+        # tool; turn that into a not-found exit instead of printing it as success.
+        if isinstance(resp, dict) and resp.get("error"):
+            from ...errors import NotFoundError
+
+            raise NotFoundError(resp["error"])
+
+        if example:
+            import yaml
+
+            settings = catalog.example_settings(resp)
+            output.emit(
+                {"type": tool, "settings": settings},
+                state.output,
+                human=yaml.safe_dump(settings, sort_keys=False).rstrip(),
+            )
+            return
+
+        param_rows = []
+        for p in resp.get("parameters", []):
+            param_rows.append(
+                {
+                    "name": p.get("name"),
+                    "type": p.get("type"),
+                    "required": "yes" if p.get("required") else "",
+                    "default": p.get("default"),
+                    "description": (p.get("descr") or p.get("displayName") or "")[:60],
+                }
+            )
+        human = (
+            f"{resp.get('displayName', tool)}  [{tool}]\n"
+            f"{resp.get('description', '')}\n\n"
+            + output.render_table(param_rows, ["name", "type", "required", "default", "description"])
+            + "\n\nRun `tamarind schema "
+            + tool
+            + " --example` for runnable example settings."
+        )
+        output.emit(resp, state.output, human=human)

tamarind/cli/commands/files.py

@@ -0,0 +1,113 @@
+"""`tamarind files` — workspace file management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import typer
+
+from ... import rest
+from ...errors import TamarindError
+from .. import output
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command("list")
+def list_files(
+    ctx: typer.Context,
+    types: Optional[str] = typer.Option(None, "--types", help="Comma-separated extensions, e.g. 'pdb,cif'."),
+    search: Optional[str] = typer.Option(None, "--search", "-s", help="Filter filenames by substring."),
+    folder: Optional[str] = typer.Option(None, "--folder", help="List within this folder."),
+    limit: int = typer.Option(50, "--limit", help="Max files to return."),
+    offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+    metadata: bool = typer.Option(False, "--metadata", help="Include size/lastModified."),
+    all_dirs: bool = typer.Option(False, "--all", help="Recurse into subdirectories."),
+) -> None:
+    """List files in your workspace."""
+    state = ctx.obj
+    with state.rest_client() as client:
+        resp = rest.get_files(
+            client,
+            limit=limit,
+            offset=offset,
+            types=types,
+            search=search,
+            folder=folder,
+            include_all=all_dirs,
+            include_metadata=metadata,
+        )
+    files = resp.get("files") if isinstance(resp, dict) else resp
+    if not isinstance(files, list):
+        files = []
+    if files and isinstance(files[0], dict):
+        rows = [{"name": f.get("name"), "size": f.get("size"), "lastModified": f.get("lastModified")} for f in files]
+        human = output.render_table(rows, ["name", "size", "lastModified"])
+    else:
+        human = "\n".join(str(f) for f in files) or "(none)"
+    output.emit(resp, state.output, human=human)
+
+
+@app.command()
+def folders(
+    ctx: typer.Context,
+    limit: int = typer.Option(50, "--limit", help="Max folders to return."),
+    all_folders: bool = typer.Option(False, "--all", help="Load all folders."),
+) -> None:
+    """List folders in your workspace."""
+    state = ctx.obj
+    with state.rest_client() as client:
+        resp = rest.get_folders(client, limit=limit, load_all=all_folders)
+    folder_list = resp.get("folders") if isinstance(resp, dict) else resp
+    if not isinstance(folder_list, list):
+        folder_list = []
+    output.emit(resp, state.output, human="\n".join(str(f) for f in folder_list) or "(none)")
+
+
+@app.command()
+def upload(
+    ctx: typer.Context,
+    path: Path = typer.Argument(..., exists=True, dir_okay=False, readable=True, help="Local file to upload."),
+    name: Optional[str] = typer.Option(None, "--name", help="Remote filename (default: the local basename)."),
+) -> None:
+    """Upload a local file to your workspace (two-step presigned PUT)."""
+    state = ctx.obj
+    remote = name or path.name
+    with state.rest_client() as client:
+        signed = rest.upload_file_url(client, filename=remote)
+    # The endpoint may return a non-dict error sentinel (e.g. -1) instead of an
+    # object; don't crash on .get — surface a clean error.
+    url = signed.get("signedUrl") if isinstance(signed, dict) else None
+    if not url:
+        raise TamarindError("Upload did not return a signed URL.", detail=signed)
+    output.info(f"Uploading {path} → {remote}…", state.output)
+    with path.open("rb") as fh:
+        put = httpx.put(url, content=fh.read(), timeout=300.0)
+    put.raise_for_status()
+    output.emit(
+        {"ok": True, "filename": remote, "bytes": path.stat().st_size},
+        state.output,
+        human=f"uploaded {remote}",
+    )
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    path: Optional[str] = typer.Argument(None, help="File path to delete."),
+    folder: Optional[str] = typer.Option(None, "--folder", help="Delete every file under this folder instead."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Delete a file, or every file under a folder."""
+    state = ctx.obj
+    if not path and not folder:
+        raise TamarindError("Provide a file path or --folder <name>.")
+    target = path or f"folder {folder}"
+    if not yes and not state.output.json:
+        typer.confirm(f"Delete {target}?", abort=True)
+    with state.rest_client() as client:
+        resp = rest.delete_file(client, file_path=path, folder=folder)
+    human = resp.get("message", resp) if isinstance(resp, dict) else resp
+    output.emit(resp, state.output, human=str(human))