amina-cli 0.2.6__tar.gz → 0.2.7__tar.gz

{amina_cli-0.2.6 → amina_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amina-cli
-Version: 0.2.6
+Version: 0.2.7
 Summary: CLI for AminoAnalytica protein engineering platform
 Project-URL: Homepage, https://aminoanalytica.com
 Project-URL: Documentation, https://docs.aminoanalytica.com

{amina_cli-0.2.6 → amina_cli-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amina-cli"
-version = "0.2.6"
+version = "0.2.7"
 description = "CLI for AminoAnalytica protein engineering platform"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{amina_cli-0.2.6 → amina_cli-0.2.7}/src/amina_cli/__init__.py

@@ -9,4 +9,4 @@ Quick start:
     amina run esmfold --sequence "MKFLILLFNILCLFPVLAADNH"
 """
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"

{amina_cli-0.2.6 → amina_cli-0.2.7}/src/amina_cli/client.py

@@ -20,7 +20,13 @@ from typing import Any, Optional
 from uuid import uuid4
 
 from amina_cli.auth import get_api_key, AuthError
-from amina_cli.registry import get_submit_endpoint, get_status_endpoint, get_queued_status_endpoint, ToolNotFoundError
+from amina_cli.registry import (
+    get_submit_endpoint,
+    get_status_endpoint,
+    get_queued_status_endpoint,
+    get_cancel_endpoint,
+    ToolNotFoundError,
+)
 
 
 # Default polling configuration
@@ -895,6 +901,68 @@ def check_queued_job_status_sync(job_id: str) -> dict[str, Any]:
     return asyncio.run(check_queued_job_status(job_id))
 
 
+async def cancel_job(job_id: str, api_key: Optional[str] = None) -> dict[str, Any]:
+    """
+    Cancel a queued or running job.
+
+    Args:
+        job_id: Job ID to cancel
+        api_key: Optional API key (uses stored key if not provided)
+
+    Returns:
+        Dict with status info:
+        - {"status": "cancelled"} on success
+        - {"status": "not_found"} if job doesn't exist
+        - {"status": "already_finished"} if job already completed/failed/cancelled
+
+    Raises:
+        AuthenticationError: If API key is invalid
+        ToolExecutionError: If request fails unexpectedly
+    """
+    if api_key is None:
+        try:
+            api_key = get_api_key()
+        except AuthError as e:
+            raise AuthenticationError(str(e))
+
+    cancel_endpoint = get_cancel_endpoint()
+    url = f"{cancel_endpoint}?job_id={job_id}"
+
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        try:
+            response = await client.post(url, headers={"Authorization": f"Bearer {api_key}"})
+        except httpx.RequestError as e:
+            raise ToolExecutionError(f"Network error cancelling job: {str(e)}")
+
+        if response.status_code == 401:
+            raise AuthenticationError("Invalid API key. Get a new one at: https://app.aminoanalytica.com/settings/api")
+
+        if response.status_code == 404:
+            return {"status": "not_found", "error": "Job not found"}
+
+        if response.status_code == 409:
+            return {"status": "already_finished", "error": "Job already finished"}
+
+        if response.status_code == 200:
+            return response.json()
+
+        raise ToolExecutionError(f"Cancel failed with HTTP {response.status_code}: {response.text}")
+
+
+def cancel_job_sync(job_id: str, api_key: Optional[str] = None) -> dict[str, Any]:
+    """
+    Synchronous wrapper for cancel_job.
+
+    Args:
+        job_id: Job ID to cancel
+        api_key: Optional API key
+
+    Returns:
+        Dict with status info
+    """
+    return asyncio.run(cancel_job(job_id, api_key))
+
+
 def check_endpoint_health(tool_name: str) -> bool:
     """
     Check if a tool's endpoint is reachable.

{amina_cli-0.2.6 → amina_cli-0.2.7}/src/amina_cli/commands/jobs_cmd.py

@@ -335,6 +335,80 @@ def wait(
         raise typer.Exit(1)
 
 
+@app.command("cancel")
+def cancel(
+    job_ids: list[str] = typer.Argument(
+        ...,
+        help="Job ID(s) to cancel",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output as JSON",
+    ),
+):
+    """
+    Cancel one or more queued or running jobs.
+
+    Sends a cancellation request to the server. Credits are fully refunded.
+
+    Examples:
+        amina jobs cancel abc123
+        amina jobs cancel abc123 def456
+        amina jobs cancel abc123 --json
+    """
+    from amina_cli.auth import get_job_info, update_job_status
+    from amina_cli.client import cancel_job_sync, ToolExecutionError
+
+    results = []
+
+    for job_id in job_ids:
+        job_info = get_job_info(job_id)
+
+        if not job_info:
+            results.append({"job_id": job_id, "status": "not_found", "error": "Job not found in local history"})
+            continue
+
+        full_job_id = job_info.get("job_id", job_id)
+
+        try:
+            cancel_result = cancel_job_sync(full_job_id)
+            status = cancel_result.get("status", "error")
+
+            if status == "cancelled":
+                update_job_status(full_job_id, "cancelled")
+
+            results.append(
+                {
+                    "job_id": full_job_id,
+                    "tool_name": job_info.get("tool_name", ""),
+                    **cancel_result,
+                }
+            )
+        except ToolExecutionError as e:
+            results.append({"job_id": full_job_id, "status": "error", "error": str(e)})
+
+    if json_output:
+        console.print(json.dumps(results, indent=2, default=str))
+        return
+
+    for result in results:
+        job_id_short = result.get("job_id", "")[:8]
+        status_str = result.get("status", "error")
+        tool_name = result.get("tool_name", "")
+        label = f" ({tool_name})" if tool_name else ""
+
+        if status_str == "cancelled":
+            console.print(f"[green]\u2713[/green] {job_id_short}...{label}: [green]cancelled[/green]")
+        elif status_str == "already_finished":
+            console.print(f"[yellow]\u2717[/yellow] {job_id_short}...{label}: [yellow]already finished[/yellow]")
+        elif status_str == "not_found":
+            console.print(f"[dim]?[/dim] {job_id_short}...: [dim]not found[/dim]")
+        else:
+            error = result.get("error", "")
+            console.print(f"[red]\u2717[/red] {job_id_short}...{label}: [red]{status_str}[/red] - {error}")
+
+
 @app.command("download")
 def download(
     job_id: str = typer.Argument(

amina_cli-0.2.7/src/amina_cli/commands/tools/analysis/residue_accessibility.py

@@ -0,0 +1,121 @@
+"""Residue Accessibility analysis tool for the Amina CLI."""
+
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+
+METADATA = {
+    "name": "residue_accessibility",
+    "display_name": "Residue Accessibility",
+    "category": "analysis",
+    "description": "Score residues for binder accessibility beyond SASA using depth, visibility, and curvature",
+    "modal_function_name": "residue_accessibility_worker",
+    "modal_app_name": "residue-accessibility-api",
+    "status": "available",
+    "outputs": {
+        "json_filepath": "Full structured results (residues, patches, recommendation)",
+        "csv_filepath": "Per-residue accessibility scores in CSV format",
+        "pdb_filepath": "PDB with B-factors set to accessibility tier scores",
+    },
+}
+
+console = Console()
+
+
+def register(app: typer.Typer):
+    """Register this tool's command with the app."""
+    from amina_cli.commands.tools import run_tool_with_progress
+
+    @app.command("residue-accessibility")
+    def run_residue_accessibility(
+        pdb: Path = typer.Option(
+            ...,
+            "--pdb",
+            "-p",
+            help="Path to PDB file containing protein structure",
+            exists=True,
+        ),
+        output: Optional[Path] = typer.Option(
+            None,
+            "--output",
+            "-o",
+            help="Output directory for results (required unless --background)",
+        ),
+        residues: Optional[str] = typer.Option(
+            None,
+            "--residues",
+            "-r",
+            help="Residues to score in CHAIN:RESNUM format (e.g., 'A:42,A:43,B:10'). "
+            "If omitted, all surface-exposed residues are scored.",
+        ),
+        rsa_threshold: float = typer.Option(
+            0.20,
+            "--rsa-threshold",
+            help="RSA cutoff for the exposure gate (0.0-1.0). Residues below this are excluded.",
+        ),
+        n_rays: int = typer.Option(
+            200,
+            "--n-rays",
+            help="Number of hemisphere rays per residue for visibility scoring (10-1000).",
+        ),
+        job_name: Optional[str] = typer.Option(
+            None,
+            "--job-name",
+            "-j",
+            help="Custom job name for output files (default: random 4-letter code)",
+        ),
+        background: bool = typer.Option(
+            False,
+            "--background",
+            "-b",
+            help="Submit job and return immediately without waiting for completion",
+        ),
+    ):
+        """
+        Score protein residues for binder accessibility.
+
+        Goes beyond SASA to measure residue depth, outward visibility (ray casting),
+        and surface curvature. Returns a ranked list of residues scored 0–1 for
+        binder accessibility.
+
+        Examples:
+            amina run residue-accessibility --pdb ./target.pdb -o ./results/
+            amina run residue-accessibility --pdb ./target.pdb -r "A:42,A:43,A:45" -o ./results/
+            amina run residue-accessibility --pdb ./target.pdb --rsa-threshold 0.15 -o ./results/
+            amina run residue-accessibility --pdb ./target.pdb -j myjob -o ./results/ --background
+        """
+        # Validate required options
+        if output is None and not background:
+            console.print("[red]Error:[/red] --output / -o is required (unless using --background)")
+            raise typer.Exit(1)
+
+        # Validate residue format if provided
+        if residues:
+            for token in residues.split(","):
+                token = token.strip()
+                if ":" not in token:
+                    console.print(
+                        f"[red]Error:[/red] Invalid residue format '{token}'. Expected CHAIN:RESNUM (e.g., 'A:42')."
+                    )
+                    raise typer.Exit(1)
+
+        # Read PDB file content
+        pdb_content = pdb.read_text()
+        console.print(f"Read PDB file: {pdb.name}")
+
+        # Build params dict matching worker's expected fields
+        params = {
+            "pdb_content": pdb_content,
+            "rsa_threshold": rsa_threshold,
+            "n_rays": n_rays,
+        }
+
+        if residues:
+            params["residues"] = residues
+
+        if job_name:
+            params["job_name"] = job_name
+
+        # Execute
+        run_tool_with_progress("residue_accessibility", params, output, background=background)

{amina_cli-0.2.6 → amina_cli-0.2.7}/src/amina_cli/registry.py

@@ -80,6 +80,17 @@ def get_queued_status_endpoint() -> str:
     return f"{base}-queued-job-status.modal.run"
 
 
+def get_cancel_endpoint() -> str:
+    """
+    Get the cancel_job endpoint URL.
+
+    Returns:
+        Cancel job endpoint URL (job_id added as query param by client)
+    """
+    base = _get_gateway_base()
+    return f"{base}-cancel-job.modal.run"
+
+
 # Legacy function for backwards compatibility
 def get_tool_endpoint(name: str) -> str:
     """