galaxy-cli 1.0.0__tar.gz

galaxy_cli-1.0.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 cli-anything
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

galaxy_cli-1.0.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: galaxy-cli
+Version: 1.0.0
+Summary: CLI harness for the Galaxy bioinformatics platform
+Author: cli-anything
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# galaxy-cli
+
+CLI harness for the [Galaxy](https://galaxyproject.org/) bioinformatics platform.
+It wraps Galaxy's REST API to provide command-line and REPL access to histories,
+datasets, tools, workflows, jobs, and libraries.
+
+This project was initially generated with `cli-anything` and then refined into
+the standalone `galaxy-cli` package.
+
+## Prerequisites
+
+- Python 3.10+
+- A running Galaxy server
+- A Galaxy API key from your target instance
+
+## Installation
+
+Install from PyPI with `uv` or `pip`:
+
+```bash
+uv tool install galaxy-cli
+```
+
+```bash
+python3 -m pip install galaxy-cli
+```
+
+For local development from this repository:
+
+```bash
+python3 -m pip install .
+```
+
+Verify installation:
+
+```bash
+which galaxy-cli
+galaxy-cli --version
+```
+
+## Configuration
+
+Set your Galaxy server URL and API key:
+
+```bash
+export GALAXY_URL=https://usegalaxy.org
+export GALAXY_API_KEY=your-api-key
+
+galaxy-cli config test
+```
+
+## Usage
+
+```bash
+galaxy-cli history list
+galaxy-cli history create "My Analysis"
+galaxy-cli tool search "bowtie"
+galaxy-cli --json workflow list
+```
+
+Run the REPL:
+
+```bash
+galaxy-cli
+```
+
+## Tests
+
+```bash
+python3 -m pytest cli_anything/galaxy/tests/ -v
+```

galaxy_cli-1.0.0/README.md

@@ -0,0 +1,71 @@
+# galaxy-cli
+
+CLI harness for the [Galaxy](https://galaxyproject.org/) bioinformatics platform.
+It wraps Galaxy's REST API to provide command-line and REPL access to histories,
+datasets, tools, workflows, jobs, and libraries.
+
+This project was initially generated with `cli-anything` and then refined into
+the standalone `galaxy-cli` package.
+
+## Prerequisites
+
+- Python 3.10+
+- A running Galaxy server
+- A Galaxy API key from your target instance
+
+## Installation
+
+Install from PyPI with `uv` or `pip`:
+
+```bash
+uv tool install galaxy-cli
+```
+
+```bash
+python3 -m pip install galaxy-cli
+```
+
+For local development from this repository:
+
+```bash
+python3 -m pip install .
+```
+
+Verify installation:
+
+```bash
+which galaxy-cli
+galaxy-cli --version
+```
+
+## Configuration
+
+Set your Galaxy server URL and API key:
+
+```bash
+export GALAXY_URL=https://usegalaxy.org
+export GALAXY_API_KEY=your-api-key
+
+galaxy-cli config test
+```
+
+## Usage
+
+```bash
+galaxy-cli history list
+galaxy-cli history create "My Analysis"
+galaxy-cli tool search "bowtie"
+galaxy-cli --json workflow list
+```
+
+Run the REPL:
+
+```bash
+galaxy-cli
+```
+
+## Tests
+
+```bash
+python3 -m pytest cli_anything/galaxy/tests/ -v
+```

galaxy_cli-1.0.0/cli_anything/galaxy/__init__.py

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

galaxy_cli-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()

galaxy_cli-1.0.0/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"),
+    }

galaxy_cli-1.0.0/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")
+    ]

galaxy_cli-1.0.0/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", ""),
+    }

galaxy_cli-1.0.0/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,
+    }

galaxy_cli-1.0.0/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,
+    }

galaxy_cli-1.0.0/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"}