galaxy-cli 1.0.0__py3-none-any.whl

cli_anything/galaxy/core/tool.py

@@ -0,0 +1,176 @@
+"""Tool management — list, search, show, run Galaxy tools."""
+
+
+def _searchable_text(tool):
+    return " ".join(
+        [
+            tool.get("id", ""),
+            tool.get("name", ""),
+            tool.get("description", ""),
+            tool.get("section", ""),
+        ]
+    ).lower()
+
+
+def _normalize_tool_dict(tool, section_id=None):
+    if section_id and tool.get("panel_section_id") != section_id:
+        return None
+    return {
+        "id": tool.get("id", ""),
+        "name": tool.get("name", ""),
+        "version": tool.get("version", ""),
+        "description": tool.get("description", ""),
+        "section": tool.get("panel_section_name", ""),
+    }
+
+
+def _resolve_search_hits(client, tools, section_id=None):
+    """Resolve string-only search hits into full tool records."""
+    if not tools or not all(isinstance(tool, str) for tool in tools):
+        return tools
+
+    all_tools = client.get("tools", params={"in_panel": False})
+    by_id = {}
+    for tool in all_tools:
+        if isinstance(tool, dict) and tool.get("id"):
+            by_id[tool["id"]] = tool
+
+    resolved = []
+    for tool_id in tools:
+        tool = by_id.get(tool_id)
+        if tool is None:
+            continue
+        if section_id and tool.get("panel_section_id") != section_id:
+            continue
+        resolved.append(tool)
+    return resolved
+
+
+def list_tools(client, query=None, section_id=None):
+    """List available tools, optionally filtered by search or section."""
+    params = {"in_panel": False}
+    if query:
+        params["q"] = query
+    tools = client.get("tools", params=params)
+    tools = _resolve_search_hits(client, tools, section_id=section_id)
+    results = []
+    for t in tools:
+        if isinstance(t, dict):
+            normalized = _normalize_tool_dict(t, section_id=section_id)
+            if normalized is not None:
+                results.append(normalized)
+    return results
+
+
+def search_tools(client, query):
+    """Search tools by name or description."""
+    query = (query or "").strip()
+    if not query:
+        return []
+
+    # First try Galaxy's native search behavior.
+    direct_results = list_tools(client, query=query)
+    if direct_results:
+        return direct_results
+
+    terms = [term.lower() for term in query.split() if term.strip()]
+    if len(terms) <= 1:
+        return direct_results
+
+    # Fallback: keyword AND matching across ID, name, description, and section.
+    all_tools = list_tools(client)
+    ranked = []
+    for tool in all_tools:
+        haystack = _searchable_text(tool)
+        if all(term in haystack for term in terms):
+            score = 0
+            name = tool.get("name", "").lower()
+            description = tool.get("description", "").lower()
+            tool_id = tool.get("id", "").lower()
+            for term in terms:
+                if term in name:
+                    score += 3
+                if term in description:
+                    score += 2
+                if term in tool_id:
+                    score += 2
+            ranked.append((score, tool))
+
+    ranked.sort(key=lambda item: (-item[0], item[1].get("name", ""), item[1].get("id", "")))
+    return [tool for _, tool in ranked]
+
+
+def show_tool(client, tool_id):
+    """Show detailed info about a tool, including its inputs."""
+    info = client.get(f"tools/{tool_id}", params={"io_details": True})
+    inputs = []
+    for inp in info.get("inputs", []):
+        inputs.append({
+            "name": inp.get("name", ""),
+            "label": inp.get("label", ""),
+            "type": inp.get("type", ""),
+            "value": inp.get("value", ""),
+            "optional": inp.get("optional", False),
+            "help": inp.get("help", ""),
+        })
+    outputs = []
+    for out in info.get("outputs", []):
+        outputs.append({
+            "name": out.get("name", ""),
+            "format": out.get("format", ""),
+            "label": out.get("label", ""),
+        })
+    return {
+        "id": info.get("id", tool_id),
+        "name": info.get("name", ""),
+        "version": info.get("version", ""),
+        "description": info.get("description", ""),
+        "edam_topics": info.get("edam_topics", []),
+        "edam_operations": info.get("edam_operations", []),
+        "requirements": [
+            {"name": r.get("name", ""), "version": r.get("version", "")}
+            for r in info.get("requirements", [])
+        ],
+        "inputs": inputs,
+        "outputs": outputs,
+        "help": info.get("help", ""),
+    }
+
+
+def run_tool(client, tool_id, history_id, inputs=None):
+    """Run a tool with given inputs in a history.
+
+    Args:
+        client: GalaxyClient instance.
+        tool_id: Tool identifier.
+        history_id: Target history for outputs.
+        inputs: Dict of tool parameter name -> value.
+    """
+    payload = {
+        "tool_id": tool_id,
+        "history_id": history_id,
+        "inputs": inputs or {},
+    }
+    result = client.post("tools", json_data=payload)
+    jobs = result.get("jobs", [])
+    outputs = result.get("outputs", [])
+    return {
+        "tool_id": tool_id,
+        "history_id": history_id,
+        "jobs": [
+            {
+                "id": j.get("id", ""),
+                "state": j.get("state", ""),
+                "tool_id": j.get("tool_id", ""),
+            }
+            for j in jobs
+        ],
+        "outputs": [
+            {
+                "id": o.get("id", ""),
+                "name": o.get("name", ""),
+                "extension": o.get("extension", ""),
+            }
+            for o in outputs
+        ],
+    }

cli_anything/galaxy/core/workflow.py

@@ -0,0 +1,131 @@
+"""Workflow management — import, export, list, show, run, delete workflows."""
+
+import json
+from pathlib import Path
+
+
+def list_workflows(client, published=False):
+    """List workflows for the current user."""
+    params = {}
+    if published:
+        params["show_published"] = True
+    workflows = client.get("workflows", params=params)
+    return [
+        {
+            "id": w.get("id", ""),
+            "name": w.get("name", ""),
+            "owner": w.get("owner", ""),
+            "published": w.get("published", False),
+            "deleted": w.get("deleted", False),
+            "step_count": w.get("number_of_steps", 0),
+            "update_time": w.get("update_time", ""),
+            "tags": w.get("tags", []),
+        }
+        for w in workflows
+    ]
+
+
+def show_workflow(client, workflow_id):
+    """Show detailed info about a workflow."""
+    info = client.get(f"workflows/{workflow_id}")
+    steps = {}
+    for step_id, step in info.get("steps", {}).items():
+        steps[step_id] = {
+            "id": step.get("id", ""),
+            "type": step.get("type", ""),
+            "tool_id": step.get("tool_id"),
+            "label": step.get("label", ""),
+            "annotation": step.get("annotation", ""),
+            "input_connections": step.get("input_connections", {}),
+        }
+    inputs = {}
+    for inp_id, inp in info.get("inputs", {}).items():
+        inputs[inp_id] = {
+            "label": inp.get("label", ""),
+            "value": inp.get("value", ""),
+        }
+    return {
+        "id": info.get("id", workflow_id),
+        "name": info.get("name", ""),
+        "owner": info.get("owner", ""),
+        "annotation": info.get("annotation", ""),
+        "published": info.get("published", False),
+        "step_count": len(steps),
+        "steps": steps,
+        "inputs": inputs,
+        "tags": info.get("tags", []),
+        "version": info.get("version", 0),
+        "update_time": info.get("update_time", ""),
+    }
+
+
+def import_workflow(client, workflow_path=None, workflow_dict=None):
+    """Import a workflow from a file or dict."""
+    if workflow_path:
+        path = Path(workflow_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Workflow file not found: {workflow_path}")
+        workflow_dict = json.loads(path.read_text())
+    if not workflow_dict:
+        raise ValueError("Either workflow_path or workflow_dict must be provided")
+    result = client.post("workflows", json_data={"workflow": workflow_dict})
+    return {
+        "id": result.get("id", ""),
+        "name": result.get("name", ""),
+        "status": "imported",
+    }
+
+
+def export_workflow(client, workflow_id, output_path=None):
+    """Export a workflow to Galaxy format JSON."""
+    info = client.get(f"workflows/{workflow_id}/download")
+    if output_path:
+        path = Path(output_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(info, indent=2))
+        return {"id": workflow_id, "output": str(path), "status": "exported"}
+    return info
+
+
+def run_workflow(client, workflow_id, history_id=None, inputs=None, params=None,
+                 new_history_name=None):
+    """Run a workflow.
+
+    Args:
+        client: GalaxyClient instance.
+        workflow_id: Workflow ID to run.
+        history_id: Existing history to put outputs in.
+        inputs: Dict mapping step input labels/indices to dataset IDs.
+        params: Dict mapping step indices to parameter overrides.
+        new_history_name: If set, create a new history with this name for outputs.
+    """
+    payload = {"workflow_id": workflow_id}
+    if new_history_name:
+        payload["history"] = f"hist_name={new_history_name}"
+    elif history_id:
+        payload["history_id"] = history_id
+
+    if inputs:
+        # Convert simple {step_index: dataset_id} to Galaxy API format
+        ds_map = {}
+        for step_key, dataset_id in inputs.items():
+            ds_map[str(step_key)] = {"src": "hda", "id": dataset_id}
+        payload["ds_map"] = ds_map
+
+    if params:
+        payload["parameters"] = params
+
+    result = client.post(f"workflows/{workflow_id}/invocations", json_data=payload)
+    return {
+        "id": result.get("id", ""),
+        "workflow_id": workflow_id,
+        "history_id": result.get("history_id", history_id or ""),
+        "state": result.get("state", ""),
+        "status": "invoked",
+    }
+
+
+def delete_workflow(client, workflow_id):
+    """Delete a workflow."""
+    client.delete(f"workflows/{workflow_id}")
+    return {"id": workflow_id, "status": "deleted"}