File size: 7,344 Bytes
04f192c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | #!/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())
|