Download data/scripts/run-workflow.py from introvoyz045/CopilotJ: direct link, hf CLI and curl.
- Browser
- Download file 7.34 kB
-
https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/scripts/run-workflow.py
- Command line
-
hf download hf://datasets/introvoyz045/CopilotJ/data/scripts/run-workflow.py
-
curl -L -o run-workflow.py https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/scripts/run-workflow.py
7.34 kB
| #!/usr/bin/env python3 | |
| # SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project. | |
| # | |
| # SPDX-License-Identifier: Apache-2.0 | |
| import asyncio | |
| import json | |
| import sys | |
| import time | |
| from pathlib import Path | |
| from typing import Any | |
| PROJECT_ROOT = Path(__file__).resolve().parents[1] | |
| if str(PROJECT_ROOT) not in sys.path: | |
| sys.path.insert(0, str(PROJECT_ROOT)) | |
| from copilotj.core.config import Config, load_config # noqa: E402 | |
| import copilotj.multiagent.tools as tools # noqa: E402 | |
| from copilotj.core import FunctionTool, ToolCall # noqa: E402 | |
| from copilotj.multiagent.leader_prompts import ( # noqa: E402 | |
| PROMPT_TOOL_EXECUTE_PYTHON_SCRIPT, | |
| PROMPT_TOOL_FOLDER_SUMMARY, | |
| PROMPT_TOOL_IMAGEJ_PERCEPTION, | |
| PROMPT_TOOL_LABEL_IMAGE, | |
| PROMPT_TOOL_RUN_MACRO, | |
| ) | |
| from copilotj.plugin.api import HTTPPluginAPI # noqa: E402 | |
| from copilotj.workflow.contract import normalize_path, parse_interface # noqa: E402 | |
| from copilotj.workflow.executor import WorkflowExecutor # noqa: E402 | |
| from copilotj.workflow.manager import BASE_DIR, RUNS_DIR, Workflow, WorkflowMeta, WorkflowStep, read_json # noqa: E402 | |
| DEFAULT_SERVER = "http://127.0.0.1:8786" | |
| OUTPUT_TIMESTAMP_FORMAT = "%Y%m%d-%H%M%S" | |
| def main() -> int: | |
| try: | |
| workflow = prompt_workflow() | |
| inputs = prompt_inputs(workflow) | |
| server = prompt_text("CopilotJ server", DEFAULT_SERVER) | |
| results = asyncio.run(execute_workflow(workflow, inputs, server)) | |
| print(format_results(results)) | |
| return 1 if any(not result["ok"] for result in results) else 0 | |
| except Exception as error: | |
| print(f"Error: {error}", file=sys.stderr) | |
| return 1 | |
| def prompt_workflow() -> Workflow: | |
| workflows = list_workflows() | |
| if workflows: | |
| print("Available workflows:") | |
| for index, workflow_path in enumerate(workflows, 1): | |
| workflow = load_workflow_path(workflow_path) | |
| print(f" {index}. {workflow.meta.name} ({workflow.meta.id})") | |
| answer = prompt_text("Choose workflow number") | |
| workflow_ref = resolve_workflow_ref(answer, workflows) | |
| return load_workflow(workflow_ref) | |
| def list_workflows() -> list[Path]: | |
| if not BASE_DIR.exists(): | |
| return [] | |
| return sorted(path / "workflow.json" for path in BASE_DIR.iterdir() if (path / "workflow.json").exists()) | |
| def resolve_workflow_ref(answer: str, workflows: list[Path]) -> str: | |
| if answer.isdigit() and workflows: | |
| index = int(answer) | |
| if 1 <= index <= len(workflows): | |
| return str(workflows[index - 1]) | |
| raise ValueError(f"Workflow selection {index} is out of range.") | |
| return answer | |
| def load_workflow(workflow_ref: str) -> Workflow: | |
| path = Path(workflow_ref).expanduser() | |
| if path.is_dir(): | |
| return load_workflow_path(path / "workflow.json") | |
| if path.exists(): | |
| return load_workflow_path(path) | |
| return load_workflow_path(BASE_DIR / workflow_ref / "workflow.json") | |
| def load_workflow_path(path: Path) -> Workflow: | |
| raw = read_json(path) | |
| return Workflow( | |
| meta=meta_from_raw(raw), | |
| steps=[WorkflowStep(id=step["id"], action=step["action"]) for step in raw.get("steps", [])], | |
| schema_version=raw.get("schema_version", "2.0"), | |
| interface=parse_interface(raw), | |
| dataset_pattern=raw.get("dataset_pattern"), | |
| outputs=raw.get("outputs"), | |
| ) | |
| def meta_from_raw(raw: dict[str, Any]) -> WorkflowMeta: | |
| meta = raw.get("meta", {}) | |
| return WorkflowMeta( | |
| id=meta.get("id"), | |
| name=meta.get("name"), | |
| version=meta.get("version", "1.0"), | |
| about=meta.get("about"), | |
| tags=meta.get("tags"), | |
| source=meta.get("source", "derived"), | |
| created_at=meta.get("created_at"), | |
| updated_at=meta.get("updated_at"), | |
| ) | |
| def prompt_inputs(workflow: Workflow) -> dict[str, Any]: | |
| inputs = {} | |
| specs = workflow.interface.inputs if workflow.interface else {} | |
| inputs.update(prompt_file_inputs(specs)) | |
| if "output_dir" in specs: | |
| default_output = default_output_dir(workflow) | |
| inputs["output_dir"] = prompt_text("Output directory", default_output) | |
| print("Optional overrides: enter name=value, blank line to continue.") | |
| while override := input("> ").strip(): | |
| name, value = parse_override(override) | |
| inputs[name] = value | |
| return inputs | |
| def default_output_dir(workflow: Workflow) -> str: | |
| timestamp = time.strftime(OUTPUT_TIMESTAMP_FORMAT) | |
| return str(RUNS_DIR / f"{timestamp}-{workflow.meta.id}") | |
| def prompt_file_inputs(specs: dict[str, Any]) -> dict[str, str]: | |
| names = [name for name, spec in specs.items() if isinstance(spec, dict) and spec.get("type") == "file"] | |
| return {name: prompt_path(f"Input file/folder for '{name}'") for name in names} | |
| def prompt_path(label: str) -> str: | |
| """Prompt for a path; `input()` gets no shell expansion, so `~` arrives verbatim.""" | |
| path = normalize_path(prompt_text(label)) | |
| if not Path(path).exists(): | |
| raise ValueError(f"{label}: path does not exist: {path}") | |
| return path | |
| def parse_override(override: str) -> tuple[str, str]: | |
| if "=" not in override: | |
| raise ValueError(f"Invalid override '{override}'. Expected name=value.") | |
| name, value = override.split("=", 1) | |
| return name.strip(), value.strip() | |
| def prompt_text(label: str, default: str | None = None) -> str: | |
| suffix = f" [{default}]" if default else "" | |
| answer = input(f"{label}{suffix}: ").strip() | |
| if answer: | |
| return answer | |
| if default is not None: | |
| return default | |
| raise ValueError(f"{label} is required.") | |
| async def execute_workflow(workflow: Workflow, inputs: dict[str, Any], server: str) -> list[dict[str, Any]]: | |
| cfg = load_config() | |
| api = HTTPPluginAPI(server) | |
| try: | |
| executor = WorkflowExecutor(ScriptWorkflowAgent(api.attach_single_client(), cfg=cfg)) | |
| return await executor.execute_workflow(workflow, stop_on_error=True, inputs=inputs) | |
| finally: | |
| await api.close() | |
| def format_results(results: list[dict[str, Any]]) -> str: | |
| lines = ["Workflow execution results:"] | |
| for result in results: | |
| lines.append(format_result(result)) | |
| return "\n".join(lines) | |
| def format_result(result: dict[str, Any]) -> str: | |
| if not result["ok"]: | |
| return f"FAIL step {result['step_id']}: {result['action'].get('name', 'unknown')} - {result['error']}" | |
| if result["step_id"] == "outputs": | |
| return f"OK outputs: {json.dumps(result['result'], ensure_ascii=False)}" | |
| return f"OK step {result['step_id']}: {result['action'].get('name', 'unknown')}" | |
| class ScriptWorkflowAgent: | |
| def __init__(self, api, *, cfg: Config): | |
| self.plugin_tools = tools.PluginTools(api, cfg=cfg) | |
| self.tools = [ | |
| FunctionTool(self.plugin_tools.imagej_perception, PROMPT_TOOL_IMAGEJ_PERCEPTION), | |
| FunctionTool(self.plugin_tools.run_macro, PROMPT_TOOL_RUN_MACRO), | |
| FunctionTool(tools.folder_summary, PROMPT_TOOL_FOLDER_SUMMARY), | |
| FunctionTool(tools.execute_python_script, PROMPT_TOOL_EXECUTE_PYTHON_SCRIPT), | |
| FunctionTool(self.plugin_tools.label_image, PROMPT_TOOL_LABEL_IMAGE), | |
| ] | |
| async def _call_tool(self, tool_call: ToolCall) -> Any: | |
| return await tool_call.run() | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |