galaxy-cli 1.0.0__py3-none-any.whl

cli_anything/galaxy/__init__.py

@@ -0,0 +1,3 @@
+"""galaxy-cli: CLI harness for Galaxy bioinformatics platform."""
+
+__version__ = "1.0.0"

cli_anything/galaxy/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m cli_anything.galaxy"""
+
+from cli_anything.galaxy.galaxy_cli import main
+
+main()

cli_anything/galaxy/core/config.py

@@ -0,0 +1,39 @@
+"""Configuration management for Galaxy CLI."""
+
+from cli_anything.galaxy.utils.galaxy_backend import GalaxyClient
+
+
+def set_url(url):
+    """Save the Galaxy server URL."""
+    GalaxyClient.save_config("url", url.rstrip("/"))
+    return {"url": url.rstrip("/"), "status": "saved"}
+
+
+def set_key(api_key):
+    """Save the Galaxy API key."""
+    GalaxyClient.save_config("api_key", api_key)
+    return {"status": "saved"}
+
+
+def show_config():
+    """Show current configuration."""
+    cfg = GalaxyClient.load_config()
+    result = {"url": cfg.get("url", "(not set)"), "api_key": "(not set)"}
+    key = cfg.get("api_key")
+    if key:
+        result["api_key"] = key[:8] + "..." + key[-4:] if len(key) > 12 else "***"
+    return result
+
+
+def test_connection(client):
+    """Test the connection to Galaxy server."""
+    version = client.get_version()
+    user = client.whoami()
+    return {
+        "status": "connected",
+        "galaxy_version": version.get("version_major", "unknown"),
+        "extra": version.get("version_minor", ""),
+        "user": user.get("username", "unknown"),
+        "email": user.get("email", "unknown"),
+        "user_id": user.get("id", "unknown"),
+    }

cli_anything/galaxy/core/dataset.py

@@ -0,0 +1,100 @@
+"""Dataset management — upload, download, show, delete, peek at datasets."""
+
+from pathlib import Path
+
+
+def upload_dataset(client, history_id, file_path, file_type="auto", dbkey="?"):
+    """Upload a local file to a Galaxy history."""
+    result = client.upload_file(file_path, history_id, file_type=file_type, dbkey=dbkey)
+    outputs = result.get("outputs", [])
+    if outputs:
+        ds = outputs[0]
+        return {
+            "id": ds.get("id", ""),
+            "name": ds.get("name", ""),
+            "state": ds.get("state", ""),
+            "history_id": history_id,
+            "file_type": ds.get("extension", file_type),
+        }
+    return {"status": "uploaded", "history_id": history_id, "raw": result}
+
+
+def show_dataset(client, dataset_id, history_id=None):
+    """Show details of a dataset."""
+    if history_id:
+        info = client.get(f"histories/{history_id}/contents/{dataset_id}")
+    else:
+        info = client.get(f"datasets/{dataset_id}")
+    return {
+        "id": info.get("id", ""),
+        "name": info.get("name", ""),
+        "state": info.get("state", ""),
+        "extension": info.get("extension", ""),
+        "file_size": info.get("file_size", 0),
+        "genome_build": info.get("genome_build", "?"),
+        "data_type": info.get("data_type", ""),
+        "create_time": info.get("create_time", ""),
+        "update_time": info.get("update_time", ""),
+        "deleted": info.get("deleted", False),
+        "visible": info.get("visible", True),
+        "metadata": info.get("metadata", {}),
+        "history_id": info.get("history_id", history_id or ""),
+        "history_content_type": info.get("history_content_type", ""),
+        "misc_info": info.get("misc_info", ""),
+        "misc_blurb": info.get("misc_blurb", ""),
+    }
+
+
+def download_dataset(client, dataset_id, output_path):
+    """Download a dataset to a local file."""
+    return client.download_dataset(dataset_id, output_path)
+
+
+def peek_dataset(client, dataset_id, lines=10):
+    """Get a preview of dataset contents."""
+    info = client.get(f"datasets/{dataset_id}", params={"data_type": "raw_data", "provider": "base"})
+    # The peek is typically included in the dataset info
+    if "peek" in info:
+        raw_peek = info["peek"]
+        peek_lines = raw_peek.strip().split("\n")[:lines]
+        return {"id": dataset_id, "lines": peek_lines, "total_shown": len(peek_lines)}
+    # Fallback: try getting raw content directly
+    try:
+        preview = client.get(f"datasets/{dataset_id}/display", params={"offset": 0, "limit": lines})
+        if isinstance(preview, dict) and "raw" in preview:
+            peek_lines = preview["raw"].strip().split("\n")[:lines]
+            return {"id": dataset_id, "lines": peek_lines, "total_shown": len(peek_lines)}
+    except Exception:
+        pass
+    return {"id": dataset_id, "lines": [], "total_shown": 0, "note": "Preview not available"}
+
+
+def delete_dataset(client, dataset_id, history_id, purge=False):
+    """Delete a dataset from a history."""
+    payload = {"deleted": True}
+    if purge:
+        payload["purged"] = True
+    client.put(f"histories/{history_id}/contents/{dataset_id}", json_data=payload)
+    return {"id": dataset_id, "history_id": history_id, "status": "deleted", "purged": purge}
+
+
+def list_datasets(client, history_id, limit=50, offset=0, deleted=False):
+    """List datasets in a history."""
+    params = {"limit": limit, "offset": offset}
+    if deleted:
+        params["deleted"] = True
+    items = client.get(f"histories/{history_id}/contents", params=params)
+    return [
+        {
+            "id": item["id"],
+            "name": item.get("name", ""),
+            "type": item.get("type", ""),
+            "state": item.get("state", ""),
+            "extension": item.get("extension", ""),
+            "file_size": item.get("file_size", 0),
+            "deleted": item.get("deleted", False),
+            "visible": item.get("visible", True),
+        }
+        for item in items
+        if item.get("type") in ("file", "dataset")
+    ]

cli_anything/galaxy/core/history.py

@@ -0,0 +1,98 @@
+"""History management — create, list, show, delete, export Galaxy histories."""
+
+
+def list_histories(client, deleted=False, limit=50, offset=0):
+    """List histories for the current user."""
+    params = {"limit": limit, "offset": offset}
+    if deleted:
+        params["deleted"] = True
+    histories = client.get("histories", params=params)
+    return [
+        {
+            "id": h["id"],
+            "name": h.get("name", ""),
+            "state": h.get("state", ""),
+            "size": h.get("size", 0),
+            "update_time": h.get("update_time", ""),
+            "deleted": h.get("deleted", False),
+            "dataset_count": h.get("count", 0),
+        }
+        for h in histories
+    ]
+
+
+def create_history(client, name="Unnamed history"):
+    """Create a new history."""
+    result = client.post("histories", json_data={"name": name})
+    return {
+        "id": result["id"],
+        "name": result.get("name", name),
+        "state": result.get("state", ""),
+        "create_time": result.get("create_time", ""),
+    }
+
+
+def show_history(client, history_id, contents=False):
+    """Show details of a history."""
+    info = client.get(f"histories/{history_id}")
+    result = {
+        "id": info["id"],
+        "name": info.get("name", ""),
+        "state": info.get("state", ""),
+        "size": info.get("size", 0),
+        "create_time": info.get("create_time", ""),
+        "update_time": info.get("update_time", ""),
+        "annotation": info.get("annotation", ""),
+        "tags": info.get("tags", []),
+        "deleted": info.get("deleted", False),
+        "importable": info.get("importable", False),
+        "published": info.get("published", False),
+        "state_details": info.get("state_details", {}),
+    }
+    if contents:
+        items = client.get(f"histories/{history_id}/contents")
+        result["contents"] = [
+            {
+                "id": item["id"],
+                "name": item.get("name", ""),
+                "type": item.get("type", ""),
+                "state": item.get("state", ""),
+                "extension": item.get("extension", ""),
+                "deleted": item.get("deleted", False),
+                "visible": item.get("visible", True),
+            }
+            for item in items
+        ]
+    return result
+
+
+def delete_history(client, history_id, purge=False):
+    """Delete a history."""
+    payload = {}
+    if purge:
+        payload["purge"] = True
+    client.delete(f"histories/{history_id}", json_data=payload)
+    return {"id": history_id, "status": "deleted", "purged": purge}
+
+
+def update_history(client, history_id, name=None, annotation=None, tags=None):
+    """Update a history's metadata."""
+    payload = {}
+    if name is not None:
+        payload["name"] = name
+    if annotation is not None:
+        payload["annotation"] = annotation
+    if tags is not None:
+        payload["tags"] = tags
+    result = client.put(f"histories/{history_id}", json_data=payload)
+    return {"id": history_id, "updated": list(payload.keys()), "name": result.get("name", "")}
+
+
+def export_history(client, history_id):
+    """Start a history export (archive creation)."""
+    result = client.put(f"histories/{history_id}/exports")
+    return {
+        "id": history_id,
+        "status": "export_started",
+        "download_url": result.get("download_url", ""),
+    }

cli_anything/galaxy/core/invocation.py

@@ -0,0 +1,79 @@
+"""Workflow invocation management — list, show, cancel invocations."""
+
+import time
+
+
+def list_invocations(client, workflow_id=None, history_id=None, limit=50):
+    """List workflow invocations."""
+    params = {"limit": limit}
+    if workflow_id:
+        params["workflow_id"] = workflow_id
+    if history_id:
+        params["history_id"] = history_id
+    invocations = client.get("invocations", params=params)
+    return [
+        {
+            "id": inv.get("id", ""),
+            "workflow_id": inv.get("workflow_id", ""),
+            "history_id": inv.get("history_id", ""),
+            "state": inv.get("state", ""),
+            "create_time": inv.get("create_time", ""),
+            "update_time": inv.get("update_time", ""),
+        }
+        for inv in invocations
+    ]
+
+
+def show_invocation(client, invocation_id):
+    """Show details of a workflow invocation."""
+    info = client.get(f"invocations/{invocation_id}")
+    steps = []
+    for step in info.get("steps", []):
+        steps.append({
+            "id": step.get("id", ""),
+            "order_index": step.get("order_index", 0),
+            "state": step.get("state", ""),
+            "job_id": step.get("job_id"),
+            "update_time": step.get("update_time", ""),
+            "action": step.get("action"),
+        })
+    return {
+        "id": info.get("id", invocation_id),
+        "workflow_id": info.get("workflow_id", ""),
+        "history_id": info.get("history_id", ""),
+        "state": info.get("state", ""),
+        "create_time": info.get("create_time", ""),
+        "update_time": info.get("update_time", ""),
+        "steps": steps,
+        "inputs": info.get("inputs", {}),
+        "outputs": info.get("outputs", {}),
+    }
+
+
+def cancel_invocation(client, invocation_id):
+    """Cancel a running invocation."""
+    client.delete(f"invocations/{invocation_id}")
+    return {"id": invocation_id, "status": "cancelled"}
+
+
+def wait_for_invocation(client, invocation_id, max_wait=1800, poll_interval=10):
+    """Wait for a workflow invocation to complete."""
+    terminal_states = {"scheduled", "cancelled", "failed", "error"}
+    elapsed = 0
+    while elapsed < max_wait:
+        info = client.get(f"invocations/{invocation_id}")
+        state = info.get("state", "unknown")
+        # "scheduled" means all steps are scheduled (essentially done from invocation perspective)
+        if state in terminal_states:
+            return {
+                "id": invocation_id,
+                "state": state,
+                "waited_seconds": elapsed,
+            }
+        time.sleep(poll_interval)
+        elapsed += poll_interval
+    return {
+        "id": invocation_id,
+        "state": "timeout",
+        "waited_seconds": elapsed,
+    }

cli_anything/galaxy/core/job.py

@@ -0,0 +1,88 @@
+"""Job management — list, show, cancel, rerun Galaxy jobs."""
+
+import time
+
+
+def list_jobs(client, history_id=None, state=None, tool_id=None, limit=50, offset=0):
+    """List jobs, optionally filtered."""
+    params = {"limit": limit, "offset": offset, "order_by": "update_time"}
+    if history_id:
+        params["history_id"] = history_id
+    if state:
+        params["state"] = state
+    if tool_id:
+        params["tool_id"] = tool_id
+    jobs = client.get("jobs", params=params)
+    return [
+        {
+            "id": j.get("id", ""),
+            "tool_id": j.get("tool_id", ""),
+            "state": j.get("state", ""),
+            "create_time": j.get("create_time", ""),
+            "update_time": j.get("update_time", ""),
+            "exit_code": j.get("exit_code"),
+        }
+        for j in jobs
+    ]
+
+
+def show_job(client, job_id, full=False):
+    """Show details of a job."""
+    params = {"full": True} if full else {}
+    info = client.get(f"jobs/{job_id}", params=params)
+    result = {
+        "id": info.get("id", ""),
+        "tool_id": info.get("tool_id", ""),
+        "state": info.get("state", ""),
+        "create_time": info.get("create_time", ""),
+        "update_time": info.get("update_time", ""),
+        "exit_code": info.get("exit_code"),
+        "history_id": info.get("history_id", ""),
+        "command_line": info.get("command_line", ""),
+        "stdout": info.get("tool_stdout", ""),
+        "stderr": info.get("tool_stderr", ""),
+    }
+    if full:
+        result["inputs"] = info.get("inputs", {})
+        result["outputs"] = info.get("outputs", {})
+        result["params"] = info.get("params", {})
+    return result
+
+
+def cancel_job(client, job_id):
+    """Cancel a running job."""
+    client.delete(f"jobs/{job_id}")
+    return {"id": job_id, "status": "cancelled"}
+
+
+def rerun_job(client, job_id):
+    """Get parameters to rerun a job."""
+    info = client.get(f"jobs/{job_id}/build_for_rerun")
+    return {
+        "id": job_id,
+        "tool_id": info.get("id", ""),
+        "state_inputs": info.get("state_inputs", {}),
+    }
+
+
+def wait_for_job(client, job_id, max_wait=600, poll_interval=5):
+    """Wait for a job to complete. Returns final job state."""
+    terminal_states = {"ok", "error", "deleted", "paused"}
+    elapsed = 0
+    while elapsed < max_wait:
+        info = client.get(f"jobs/{job_id}")
+        state = info.get("state", "unknown")
+        if state in terminal_states:
+            return {
+                "id": job_id,
+                "state": state,
+                "exit_code": info.get("exit_code"),
+                "waited_seconds": elapsed,
+            }
+        time.sleep(poll_interval)
+        elapsed += poll_interval
+    return {
+        "id": job_id,
+        "state": "timeout",
+        "waited_seconds": elapsed,
+    }

cli_anything/galaxy/core/library.py

@@ -0,0 +1,63 @@
+"""Library management — create, list, show, manage shared data libraries."""
+
+
+def list_libraries(client, deleted=False):
+    """List data libraries."""
+    params = {}
+    if deleted:
+        params["deleted"] = True
+    libraries = client.get("libraries", params=params)
+    return [
+        {
+            "id": lib.get("id", ""),
+            "name": lib.get("name", ""),
+            "description": lib.get("description", ""),
+            "deleted": lib.get("deleted", False),
+            "create_time": lib.get("create_time", ""),
+        }
+        for lib in libraries
+    ]
+
+
+def create_library(client, name, description="", synopsis=""):
+    """Create a new data library."""
+    payload = {"name": name, "description": description, "synopsis": synopsis}
+    result = client.post("libraries", json_data=payload)
+    return {
+        "id": result.get("id", ""),
+        "name": result.get("name", name),
+        "status": "created",
+    }
+
+
+def show_library(client, library_id):
+    """Show details of a library."""
+    info = client.get(f"libraries/{library_id}")
+    return {
+        "id": info.get("id", library_id),
+        "name": info.get("name", ""),
+        "description": info.get("description", ""),
+        "synopsis": info.get("synopsis", ""),
+        "deleted": info.get("deleted", False),
+        "create_time": info.get("create_time", ""),
+    }
+
+
+def list_library_contents(client, library_id):
+    """List contents of a library."""
+    contents = client.get(f"libraries/{library_id}/contents")
+    return [
+        {
+            "id": item.get("id", ""),
+            "name": item.get("name", ""),
+            "type": item.get("type", ""),
+            "url": item.get("url", ""),
+        }
+        for item in contents
+    ]
+
+
+def delete_library(client, library_id):
+    """Delete a library."""
+    client.delete(f"libraries/{library_id}")
+    return {"id": library_id, "status": "deleted"}

cli_anything/galaxy/core/session.py

@@ -0,0 +1,103 @@
+"""Session management — local state persistence for CLI sessions.
+
+Tracks current history, last job, preferences across CLI invocations.
+"""
+
+import fcntl
+import json
+from pathlib import Path
+
+DEFAULT_SESSION_DIR = Path.home() / ".galaxy-cli"
+DEFAULT_SESSION_FILE = DEFAULT_SESSION_DIR / "session.json"
+
+
+def _locked_save_json(path, data):
+    """Save JSON with exclusive file locking to prevent corruption."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():
+        path.write_text("{}")
+    with open(path, "r+") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        try:
+            f.seek(0)
+            f.truncate()
+            json.dump(data, f, indent=2)
+            f.flush()
+        finally:
+            fcntl.flock(f, fcntl.LOCK_UN)
+
+
+def load_session(session_path=None):
+    """Load the current session state."""
+    path = Path(session_path) if session_path else DEFAULT_SESSION_FILE
+    if path.exists():
+        try:
+            return json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+    return {
+        "current_history_id": None,
+        "current_history_name": None,
+        "last_job_id": None,
+        "last_dataset_id": None,
+        "preferences": {},
+    }
+
+
+def save_session(session_data, session_path=None):
+    """Save the current session state."""
+    path = Path(session_path) if session_path else DEFAULT_SESSION_FILE
+    _locked_save_json(path, session_data)
+    return {"status": "saved", "path": str(path)}
+
+
+def set_current_history(history_id, history_name=None, session_path=None):
+    """Set the current working history."""
+    session = load_session(session_path)
+    session["current_history_id"] = history_id
+    session["current_history_name"] = history_name
+    save_session(session, session_path)
+    return {"current_history_id": history_id, "current_history_name": history_name}
+
+
+def get_current_history(session_path=None):
+    """Get the current working history ID."""
+    session = load_session(session_path)
+    return {
+        "current_history_id": session.get("current_history_id"),
+        "current_history_name": session.get("current_history_name"),
+    }
+
+
+def track_job(job_id, session_path=None):
+    """Track the last job ID in session."""
+    session = load_session(session_path)
+    session["last_job_id"] = job_id
+    save_session(session, session_path)
+
+
+def track_dataset(dataset_id, session_path=None):
+    """Track the last dataset ID in session."""
+    session = load_session(session_path)
+    session["last_dataset_id"] = dataset_id
+    save_session(session, session_path)
+
+
+def show_session(session_path=None):
+    """Show current session state."""
+    return load_session(session_path)
+
+
+def clear_session(session_path=None):
+    """Clear session state."""
+    path = Path(session_path) if session_path else DEFAULT_SESSION_FILE
+    empty = {
+        "current_history_id": None,
+        "current_history_name": None,
+        "last_job_id": None,
+        "last_dataset_id": None,
+        "preferences": {},
+    }
+    save_session(empty, session_path)
+    return {"status": "cleared"}