omicslab 1.0.0__py3-none-any.whl

omicslab/__init__.py

@@ -0,0 +1,21 @@
+from .client import Client
+from .config import Config
+from .exceptions import (
+    OmicslabError,
+    AuthError,
+    APIError,
+    NotFoundError,
+    ForbiddenError,
+)
+from ._version import __version__
+
+__all__ = [
+    "Client",
+    "Config",
+    "OmicslabError",
+    "AuthError",
+    "APIError",
+    "NotFoundError",
+    "ForbiddenError",
+    "__version__",
+]

omicslab/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

omicslab/cli/analysis_commands.py

@@ -0,0 +1,141 @@
+from typing import Optional
+
+import typer
+
+from .utils import success, error, output, get_client
+
+app = typer.Typer(help="Analysis tool catalog")
+
+
+@app.command(name="list")
+def list_analysis(
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """List analysis tools."""
+    client = get_client()
+    try:
+        result = client.analysis.list()
+        output(result, format="json" if json_output else "table")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def create(
+    url: str = typer.Option(
+        ..., "--url", "-u", help="Git repository URL of the analysis tool"
+    ),
+):
+    """Register a new analysis tool from a Git repository."""
+    client = get_client()
+    try:
+        result = client.analysis.create(url=url)
+        success(
+            f"Analysis tool '{result.get('name', result.get('id', 'unknown'))}' registered."
+        )
+        output(result)
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def get(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+):
+    """Get analysis tool details."""
+    client = get_client()
+    try:
+        result = client.analysis.get(analysis_id)
+        output(result)
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def update(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+    url: Optional[str] = typer.Option(None, "--url", "-u", help="New Git URL"),
+    allow_access: Optional[bool] = typer.Option(
+        None, "--allow-access/--deny-access", help="Allow/deny access"
+    ),
+):
+    """Update an analysis tool."""
+    client = get_client()
+    try:
+        result = client.analysis.update(analysis_id, url=url, allow_access=allow_access)
+        success("Analysis tool updated.")
+        output(result)
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def delete(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Remove an analysis tool."""
+    if not force:
+        confirm = typer.confirm(f"Delete analysis tool {analysis_id}?")
+        if not confirm:
+            raise typer.Abort()
+    client = get_client()
+    try:
+        client.analysis.delete(analysis_id)
+        success("Analysis tool deleted.")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def pin(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+):
+    """Pin an analysis tool to favorites."""
+    client = get_client()
+    try:
+        client.analysis.pin(analysis_id)
+        success("Analysis tool pinned.")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def unpin(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+):
+    """Unpin an analysis tool from favorites."""
+    client = get_client()
+    try:
+        client.analysis.unpin(analysis_id)
+        success("Analysis tool unpinned.")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def schema(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Show the parameter schema of an analysis tool."""
+    client = get_client()
+    try:
+        result = client.analysis.get_schema(analysis_id)
+        output(result, format="json" if json_output else "table")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def tags(
+    analysis_id: str = typer.Argument(..., help="Analysis tool ID"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Show tags of an analysis tool."""
+    client = get_client()
+    try:
+        result = client.analysis.get_tags(analysis_id)
+        output(result, format="json" if json_output else "table")
+    except Exception as e:
+        error(f"Failed: {e}")

omicslab/cli/auth_commands.py

@@ -0,0 +1,45 @@
+import typer
+
+from ..config import Config
+from .utils import console, success, error, get_client
+
+app = typer.Typer(help="Authentication management")
+
+
+@app.command()
+def login(
+    token: str = typer.Option(..., "--token", "-t", help="API token (omx_...)"),
+    base_url: str = typer.Option(
+        "https://platform.omicslab.io/api", "--base-url", help="Platform API base URL"
+    ),
+):
+    """Log in with an API token."""
+    if not token.startswith("omx_"):
+        error("Token must start with 'omx_'")
+        raise typer.Exit(1)
+
+    config = Config()
+    config.set_token(token)
+    config.set_base_url(base_url)
+    success(f"Logged in. Token stored in {config._config_path}")
+
+
+@app.command()
+def logout():
+    """Log out by removing the stored token."""
+    config = Config()
+    config.clear_token()
+    success("Logged out. Token removed.")
+
+
+@app.command()
+def whoami():
+    """Show the currently authenticated user (requires a valid token)."""
+    client = get_client()
+    try:
+        res = client._request("GET", "/auth/check_access_token")
+        console.print(
+            f"[green]Authenticated as:[/green] [bold]{res.get('email', 'unknown')}[/bold]"
+        )
+    except Exception as e:
+        error(f"Not authenticated: {e}")

omicslab/cli/context_commands.py

@@ -0,0 +1,137 @@
+from typing import Optional
+
+import typer
+
+from ..config import Config
+from .utils import (
+    console,
+    info,
+    success,
+    get_client,
+    select_org,
+    select_workspace,
+    select_prefix,
+)
+
+app = typer.Typer(help="Set active context (org, workspace, folder)")
+
+
+@app.callback(invoke_without_command=True)
+def use(
+    ctx: typer.Context,
+    org_id: Optional[str] = typer.Option(
+        None, "--org-id", "-o", help="Organization ID"
+    ),
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace-id", "-w", help="Workspace ID"
+    ),
+    prefix: Optional[str] = typer.Option(
+        None, "--prefix", "-p", help="Default storage prefix"
+    ),
+):
+    """Set the active org, workspace, and folder.
+
+    Run without arguments for interactive selection.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+    if org_id or workspace_id or prefix:
+        _set_from_args(org_id, workspace_id, prefix)
+    else:
+        _set_interactive()
+
+
+def _set_from_args(
+    org_id: Optional[str],
+    workspace_id: Optional[str],
+    prefix: Optional[str],
+):
+    config = Config()
+    if org_id:
+        config.set_org(org_id)
+        info(f"Org set to {org_id}")
+    if workspace_id:
+        config.set_workspace(workspace_id)
+        info(f"Workspace set to {workspace_id}")
+    if prefix is not None:
+        config.set_prefix(prefix)
+        info(f"Prefix set to {prefix or '(none)'}")
+    _show_context(config)
+
+
+def _set_interactive():
+    client = get_client()
+    config = Config()
+
+    console.print("[bold]Select organization:[/bold]")
+    org_id, org_name = select_org(client)
+    config.set_org(org_id, org_name)
+    success(f"Org set to {org_name}")
+
+    console.print("[bold]Select workspace:[/bold]")
+    ws_id, ws_name = select_workspace(client)
+    config.set_workspace(ws_id, ws_name)
+    success(f"Workspace set to {ws_name}")
+
+    console.print("[bold]Select folder (optional):[/bold]")
+    chosen_prefix = select_prefix(client, ws_id)
+    if chosen_prefix:
+        config.set_prefix(chosen_prefix)
+        info(f"Prefix set to {chosen_prefix}")
+    else:
+        config.clear_prefix()
+
+    _show_context(config)
+
+
+@app.command()
+def show():
+    """Show current context."""
+    _show_context(Config())
+
+
+def _show_context(config: Config):
+    org_id = config.get_org_id()
+    ws_id = config.get_workspace_id()
+    prefix = config.get_prefix()
+    profile = config.current_profile
+
+    from .utils import print_panel
+
+    print_panel(
+        f"Active Context (profile: {profile})",
+        {
+            "org_id": org_id or "[dim]not set[/dim]",
+            "workspace_id": ws_id or "[dim]not set[/dim]",
+            "prefix": "/" if prefix == "" else (prefix or "[dim]not set[/dim]"),
+        },
+    )
+
+
+@app.command()
+def clear(
+    org: bool = typer.Option(False, "--org", help="Clear org context"),
+    workspace: bool = typer.Option(
+        False, "--workspace", "-w", help="Clear workspace context"
+    ),
+    prefix: bool = typer.Option(False, "--prefix", "-p", help="Clear prefix"),
+    all: bool = typer.Option(False, "--all", "-a", help="Clear all context"),
+):
+    """Clear part or all of the active context."""
+    config = Config()
+    if all:
+        config.clear_org()
+        config.clear_workspace()
+        config.clear_prefix()
+        success("All context cleared.")
+    else:
+        if org:
+            config.clear_org()
+            success("Org context cleared.")
+        if workspace:
+            config.clear_workspace()
+            success("Workspace context cleared.")
+        if prefix:
+            config.clear_prefix()
+            success("Prefix cleared.")
+    _show_context(config)

omicslab/cli/job_commands.py

@@ -0,0 +1,168 @@
+import json
+from typing import Optional
+
+import typer
+
+from ..config import Config
+from .utils import success, error, output, get_client, resolve_workspace
+
+app = typer.Typer(help="Job management (analysis and studio)")
+
+
+@app.command(name="launch")
+def launch(
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace", "-w", help="Workspace ID (uses stored context if omitted)"
+    ),
+    analysis_id: Optional[str] = typer.Option(
+        None, "--analysis", "-a", help="Analysis tool ID"
+    ),
+    studio_id: Optional[str] = typer.Option(
+        None, "--studio", "-s", help="Studio tool ID"
+    ),
+    compute_id: str = typer.Option(
+        ..., "--compute", "-c", help="Compute credential ID"
+    ),
+    params: Optional[str] = typer.Option(
+        "{}", "--params", "-p", help="Job params as JSON"
+    ),
+):
+    """Launch an analysis or studio job."""
+    if not analysis_id and not studio_id:
+        error("Must specify --analysis or --studio")
+        raise typer.Exit(1)
+    if analysis_id and studio_id:
+        error("Cannot specify both --analysis and --studio")
+        raise typer.Exit(1)
+
+    client = get_client()
+    ws = resolve_workspace(client, Config(), workspace_id)
+    try:
+        params_dict = json.loads(params) if params else {}
+
+        if analysis_id:
+            result = client.jobs.launch_analysis(
+                workspace_id=ws,
+                analysis_id=analysis_id,
+                compute_id=compute_id,
+                params=params_dict,
+            )
+            job_type = "analysis"
+        else:
+            result = client.jobs.launch_studio(
+                workspace_id=ws,
+                studio_id=studio_id,
+                compute_id=compute_id,
+                params=params_dict,
+            )
+            job_type = "studio"
+
+        success(f"{job_type.capitalize()} job launched: {result.get('id', result)}")
+        output(result, format="table")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command(name="list")
+def list_jobs(
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace", "-w", help="Workspace ID (uses stored context if omitted)"
+    ),
+    job_type: str = typer.Option(
+        "analysis", "--type", "-t", help="Job type: analysis or studio"
+    ),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """List jobs in a workspace."""
+    client = get_client()
+    ws = resolve_workspace(client, Config(), workspace_id)
+    try:
+        if job_type == "analysis":
+            result = client.jobs.list_analysis(ws)
+        elif job_type == "studio":
+            result = client.jobs.list_studio(ws)
+        else:
+            error(f"Invalid job type: {job_type}")
+            raise typer.Exit(1)
+        output(result, format="json" if json_output else "table")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command(name="get")
+def get_job(
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace", "-w", help="Workspace ID (uses stored context if omitted)"
+    ),
+    job_id: str = typer.Argument(..., help="Job ID"),
+    job_type: str = typer.Option(
+        "analysis", "--type", "-t", help="Job type: analysis or studio"
+    ),
+):
+    """Get job details."""
+    client = get_client()
+    ws = resolve_workspace(client, Config(), workspace_id)
+    try:
+        if job_type == "analysis":
+            result = client.jobs.get_analysis(ws, job_id)
+        elif job_type == "studio":
+            result = client.jobs.get_studio(ws, job_id)
+        else:
+            error(f"Invalid job type: {job_type}")
+            raise typer.Exit(1)
+        output(result, format="table")
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command(name="logs")
+def get_logs(
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace", "-w", help="Workspace ID (uses stored context if omitted)"
+    ),
+    job_id: str = typer.Argument(..., help="Job ID"),
+    job_type: str = typer.Option(
+        "analysis", "--type", "-t", help="Job type: analysis or studio"
+    ),
+):
+    """Get job logs."""
+    client = get_client()
+    ws = resolve_workspace(client, Config(), workspace_id)
+    try:
+        if job_type == "analysis":
+            result = client.jobs.get_analysis_log(ws, job_id)
+        else:
+            error("Studio job logs are not yet supported via REST API")
+            raise typer.Exit(1)
+        if isinstance(result, dict) and "log" in result:
+            print(result["log"])
+        else:
+            output(result)
+    except Exception as e:
+        error(f"Failed: {e}")
+
+
+@app.command()
+def terminate(
+    workspace_id: Optional[str] = typer.Option(
+        None, "--workspace", "-w", help="Workspace ID (uses stored context if omitted)"
+    ),
+    job_id: str = typer.Argument(..., help="Job ID"),
+    job_type: str = typer.Option(
+        "analysis", "--type", "-t", help="Job type: analysis or studio"
+    ),
+):
+    """Terminate a running job."""
+    client = get_client()
+    ws = resolve_workspace(client, Config(), workspace_id)
+    try:
+        if job_type == "analysis":
+            client.jobs.terminate_analysis(ws, job_id)
+        elif job_type == "studio":
+            client.jobs.terminate_studio(ws, job_id)
+        else:
+            error(f"Invalid job type: {job_type}")
+            raise typer.Exit(1)
+        success(f"{job_type.capitalize()} job {job_id} terminated.")
+    except Exception as e:
+        error(f"Failed: {e}")