rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download language_core/executor/compiled_runner.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 8.76 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/language_core/executor/compiled_runner.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/language_core/executor/compiled_runner.py
-
curl -L -o compiled_runner.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/language_core/executor/compiled_runner.py
8.76 kB
| """ | |
| ALLI Workflow Executor: Compiled Single-Path Graph Execution Engine. | |
| Synthesizes standalone Python via codegen_handler and executes via RuntimeRunner | |
| for full parity across local_subprocess and docker_sandbox modes. | |
| """ | |
| import time | |
| from typing import Any, Dict, List, Optional, Set | |
| from language_core.runtime_events import ( | |
| EVENT_RUN_COMPLETED, | |
| EVENT_RUN_FAILED, | |
| GLOBAL_EVENT_STORE, | |
| ) | |
| from runtime_environment.active_runs import GLOBAL_ACTIVE_RUNS | |
| from runtime_environment.runner import DockerSandboxRunner, RuntimeRunner | |
| def _slice_upstream_subgraph(graph: Dict[str, Any], target_node_id: str) -> Dict[str, Any]: | |
| """Slice graph to include target_node_id and all upstream dependency nodes/edges.""" | |
| raw_nodes = graph.get("nodes") or [] | |
| raw_edges = graph.get("edges") if graph.get("edges") is not None else (graph.get("connections") or []) | |
| upstream: Set[str] = {str(target_node_id)} | |
| changed = True | |
| while changed: | |
| changed = False | |
| for e in raw_edges: | |
| src = str(e.get("source") or e.get("from_node") or "") | |
| tgt = str(e.get("target") or e.get("to_node") or "") | |
| if tgt in upstream and src and src not in upstream: | |
| upstream.add(src) | |
| changed = True | |
| return { | |
| **graph, | |
| "nodes": [n for n in raw_nodes if str(n.get("id")) in upstream], | |
| "edges": [ | |
| e for e in raw_edges | |
| if str(e.get("source") or e.get("from_node")) in upstream | |
| and str(e.get("target") or e.get("to_node")) in upstream | |
| ], | |
| } | |
| def execute_compiled_workflow_graph( | |
| graph: Dict[str, Any], | |
| timeout_seconds: float, | |
| mode: str, | |
| run_id: str, | |
| graph_revision: str, | |
| created_ts: str, | |
| start_total_time: float, | |
| target_node_id: Optional[str] = None, | |
| owner_user_id: Optional[str] = None, | |
| workspace_env: Optional[Dict[str, str]] = None, | |
| ) -> Dict[str, Any]: | |
| """Compile graph to Python and run via RuntimeRunner (local_subprocess or docker_sandbox).""" | |
| from language_core.executor.run_prep import scrub_result_secrets | |
| from lambdas.codegen_handler import generate_code_logic | |
| norm_mode = mode.strip().lower() | |
| if norm_mode in ("docker", "docker_sandbox"): | |
| runner_mode = "docker" | |
| mode_label = "docker_sandbox" | |
| elif norm_mode in ("local_subprocess", "local_compiled"): | |
| runner_mode = "local" | |
| mode_label = "local_subprocess" | |
| else: | |
| runner_mode = "auto" | |
| mode_label = "docker_sandbox" if DockerSandboxRunner.is_docker_available() else "local_subprocess" | |
| exec_graph = _slice_upstream_subgraph(graph, target_node_id) if target_node_id else graph | |
| codegen_res = generate_code_logic(graph=exec_graph, validate=True) | |
| execution_order: List[str] = list(codegen_res.get("execution_order") or []) | |
| if not codegen_res.get("success") or not codegen_res.get("python_code"): | |
| duration_ms = round((time.perf_counter() - start_total_time) * 1000, 2) | |
| diags = codegen_res.get("diagnostics") or [] | |
| err_msgs = [d.get("message", "Codegen/validation error") for d in diags if d.get("severity") == "error"] | |
| err_msg = "; ".join(err_msgs[:3]) or "Failed to synthesize executable Python from workflow graph." | |
| GLOBAL_EVENT_STORE.record_event( | |
| run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_FAILED, | |
| status="failed", code="CODEGEN-FAILED", message=err_msg, payload={"diagnostics": diags}, | |
| owner_user_id=owner_user_id, | |
| ) | |
| return { | |
| "run_id": run_id, | |
| "graph_revision": graph_revision, | |
| "cursor": GLOBAL_EVENT_STORE._seq_counters.get(run_id, 0), | |
| "success": False, | |
| "status": "failed", | |
| "mode": mode_label, | |
| "duration_ms": duration_ms, | |
| "total_duration_ms": duration_ms, | |
| "execution_order": execution_order, | |
| "execution_plan": None, | |
| "node_results": {}, | |
| "validation_errors": diags, | |
| "diagnostics": diags, | |
| "final_outputs": {}, | |
| "logs": [f"[ERROR] {err_msg}"], | |
| "stdout": "", | |
| "stderr": err_msg, | |
| "exit_code": 1, | |
| "error": err_msg, | |
| "python_code": "", | |
| } | |
| python_code = codegen_res["python_code"] | |
| runner = RuntimeRunner(default_mode=runner_mode, timeout_sec=timeout_seconds, run_id=run_id, workspace_env=workspace_env) | |
| GLOBAL_ACTIVE_RUNS.register(run_id) | |
| try: | |
| exec_res = runner.run(python_code, mode=runner_mode) | |
| except RuntimeError as exc: | |
| duration_ms = round((time.perf_counter() - start_total_time) * 1000, 2) | |
| err_str = str(exc) | |
| err_code = "ERR-SANDBOX-UNAVAILABLE" if "ERR-SANDBOX-UNAVAILABLE" in err_str else "ERR-SANDBOX-FAILED" | |
| GLOBAL_EVENT_STORE.record_event( | |
| run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_FAILED, | |
| status="failed", severity="error", code=err_code, message=err_str, | |
| owner_user_id=owner_user_id, | |
| ) | |
| return { | |
| "run_id": run_id, | |
| "graph_revision": graph_revision, | |
| "cursor": GLOBAL_EVENT_STORE._seq_counters.get(run_id, 0), | |
| "success": False, | |
| "status": "failed", | |
| "mode": mode_label, | |
| "code": err_code, | |
| "duration_ms": duration_ms, | |
| "total_duration_ms": duration_ms, | |
| "execution_order": execution_order, | |
| "execution_plan": None, | |
| "node_results": {}, | |
| "final_outputs": {}, | |
| "logs": [f"[ERROR] {err_str}"], | |
| "stdout": "", | |
| "stderr": err_str, | |
| "exit_code": 1, | |
| "error": err_str, | |
| "python_code": python_code, | |
| } | |
| finally: | |
| GLOBAL_ACTIVE_RUNS.unregister(run_id) | |
| total_ms = round((time.perf_counter() - start_total_time) * 1000, 2) | |
| per_node_ms = round(exec_res.duration_ms / max(len(execution_order), 1), 2) | |
| node_map = {str(n.get("id")): n for n in (exec_graph.get("nodes") or []) if n.get("id")} | |
| node_results: Dict[str, Any] = {} | |
| status_str = "success" if exec_res.success else "failed" | |
| for nid in execution_order: | |
| n = node_map.get(nid, {}) | |
| d = n.get("data") or {} | |
| ntype = str(n.get("node_type") or n.get("type") or d.get("node_type") or "").lower() | |
| lbl = d.get("label") or n.get("label") or ntype or nid | |
| outs = {"stdout": exec_res.stdout} if (exec_res.success and ("print" in ntype or "output" in ntype)) else {} | |
| node_results[nid] = { | |
| "run_id": run_id, | |
| "node_id": nid, | |
| "node_type": ntype, | |
| "label": lbl, | |
| "status": status_str, | |
| "config_state": "valid", | |
| "exec_state": status_str, | |
| "freshness": "current" if exec_res.success else "invalidated", | |
| "inputs": {}, | |
| "outputs": outs, | |
| "output_ports": {}, | |
| "duration_ms": per_node_ms, | |
| "retries_attempted": 0, | |
| "error": None if exec_res.success else (exec_res.stderr or "Execution failed"), | |
| "error_semantics": None, | |
| "skip_reason": None, | |
| "timestamp": created_ts, | |
| } | |
| GLOBAL_EVENT_STORE.record_event( | |
| run_id=run_id, | |
| graph_revision=graph_revision, | |
| event_type=EVENT_RUN_COMPLETED if exec_res.success else EVENT_RUN_FAILED, | |
| status=status_str, | |
| message=f"Compiled workflow ({exec_res.mode}) exited {exec_res.exit_code} in {round(exec_res.duration_ms, 2)}ms.", | |
| payload={"mode": exec_res.mode, "exit_code": exec_res.exit_code, "duration_ms": round(exec_res.duration_ms, 2)}, | |
| owner_user_id=owner_user_id, | |
| ) | |
| return scrub_result_secrets({ | |
| "run_id": run_id, | |
| "graph_revision": graph_revision, | |
| "cursor": GLOBAL_EVENT_STORE._seq_counters.get(run_id, 0), | |
| "success": exec_res.success, | |
| "status": status_str, | |
| "mode": exec_res.mode, | |
| "duration_ms": round(exec_res.duration_ms, 2), | |
| "total_duration_ms": total_ms, | |
| "execution_order": execution_order, | |
| "execution_plan": None, | |
| "node_results": node_results, | |
| "final_outputs": {"stdout": exec_res.stdout} if exec_res.success else {}, | |
| "logs": [f"[{exec_res.mode}] Exit {exec_res.exit_code} in {round(exec_res.duration_ms, 2)}ms"], | |
| "stdout": exec_res.stdout[:100000], | |
| "stderr": exec_res.stderr[:100000], | |
| "exit_code": exec_res.exit_code, | |
| "error": None if exec_res.success else (exec_res.stderr or "Compiled workflow execution failed."), | |
| "python_code": python_code, | |
| }) | |