rsnarsna
feat(backend): add hierarchical AST blueprint endpoint for Universal Playground (DEC-017)
3da49c0 Download language_core/workflow_executor.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 12.1 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/language_core/workflow_executor.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/language_core/workflow_executor.py
-
curl -L -o workflow_executor.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/language_core/workflow_executor.py
12.1 kB
| """ | |
| ALLI Connected Workflow Execution Engine - Facade (Phase 3.10 + Multi-Mode Parity). | |
| Dispatches in-process DAG execution, compiled local_subprocess/docker_sandbox runs, | |
| interactive step debugging, and authoritative cancellation. | |
| """ | |
| from collections import deque | |
| import time | |
| from typing import Any, Dict, List, Optional, Set | |
| import uuid | |
| from language_core.execution_planner import build_execution_plan | |
| from language_core.execution_session import compute_graph_hash | |
| from language_core.executor.compiled_runner import execute_compiled_workflow_graph | |
| from language_core.executor.inline_handlers import ( | |
| _execute_binary_op_node, | |
| _execute_compare_node, | |
| _execute_constant_node, | |
| _execute_if_else_node, | |
| _execute_loop_node, | |
| _execute_math_sqrt_node, | |
| _execute_print_node, | |
| _execute_variable_node, | |
| ) | |
| from language_core.executor.single_node_runner import _execute_single_node | |
| from language_core.executor.state_and_errors import ( | |
| VALID_STATE_TRANSITIONS, | |
| WorkflowExecutionError, | |
| build_validation_failure_response, | |
| handle_timeout_abort as _handle_timeout_abort, | |
| make_error_semantics, | |
| validate_state_transition, | |
| ) | |
| from language_core.executor.step_and_cancel import ( | |
| _compute_upstream_set, | |
| cancel_workflow_run, | |
| execute_workflow_step, | |
| ) | |
| from language_core.node_schema import default_registry | |
| from language_core.runtime_events import ( | |
| EVENT_NODE_CANCELLED, | |
| EVENT_NODE_FAILED, | |
| EVENT_NODE_QUEUED, | |
| EVENT_NODE_SKIPPED, | |
| EVENT_RUN_CANCELLED, | |
| EVENT_RUN_COMPLETED, | |
| EVENT_RUN_FAILED, | |
| EVENT_RUN_STARTED, | |
| EVENT_TIMEOUT, | |
| GLOBAL_EVENT_STORE, | |
| ) | |
| from lambdas.validate_handler import validate_workflow_protocol_logic | |
| from runtime_environment.active_runs import ( | |
| GLOBAL_ACTIVE_RUNS, | |
| MAX_OUTPUT_QUOTA_BYTES, | |
| measure_output_port_quota, | |
| safe_serialize_to_json, | |
| ) | |
| COMPILED_EXECUTION_MODES = {"docker", "docker_sandbox", "local_subprocess", "local_compiled", "auto"} | |
| def execute_workflow_graph( | |
| graph: Dict[str, Any], | |
| timeout_seconds: float = 5.0, | |
| owner_user_id: Optional[str] = None, | |
| target_node_id: Optional[str] = None, | |
| mode: str = "in_process", | |
| org_id: Optional[str] = None, | |
| role: Optional[str] = None, | |
| workspace_env: Optional[Dict[str, str]] = None, | |
| cached_outputs: Optional[Dict[str, Dict[str, Any]]] = None, | |
| pinned_inputs: Optional[Dict[str, Dict[str, Any]]] = None, | |
| single_node_only: bool = False, | |
| ) -> Dict[str, Any]: | |
| """Connected Workflow Execution Engine supporting in_process, local_subprocess, and docker_sandbox parity.""" | |
| from language_core.executor.run_prep import ( | |
| extract_node_pinned_input, | |
| prepare_isolated_step_execution, | |
| scrub_result_secrets, | |
| ) | |
| from language_core.workflow_migration import migrate_workflow | |
| from runtime_environment.env_injection import ( | |
| activate_run_env, | |
| build_run_env_context, | |
| graph_accesses_workspace_env, | |
| ) | |
| if graph and isinstance(graph, dict): | |
| graph = migrate_workflow(graph) | |
| if str(role or "").lower().strip() == "viewer" and graph_accesses_workspace_env(graph): | |
| raise PermissionError( | |
| "[ERR-RBAC-SECRET-DENIED] Viewers cannot execute workflows that access workspace environment variables." | |
| ) | |
| run_env_ctx = build_run_env_context(org_id=org_id, role=role, explicit_env=workspace_env) | |
| if graph.get("schema_version") != "3.0.0": | |
| raise AssertionError(f"[ERR-SCHEMA-VERSION] Non-migrated workflow reached executor (schema_version='{graph.get("schema_version")}'). Expected '3.0.0'.") | |
| start_total_time = time.perf_counter() | |
| run_id = str(graph.get("run_id") or f"run_{uuid.uuid4().hex[:12]}") | |
| created_ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) | |
| graph_revision = compute_graph_hash(graph) | |
| norm_mode = str(mode or "in_process").strip().lower() | |
| GLOBAL_EVENT_STORE.record_event( | |
| run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_STARTED, status="running", | |
| message=f"Workflow run '{run_id}' started ({norm_mode}).", | |
| payload={"graph_revision": graph_revision, "timeout_seconds": timeout_seconds, "mode": norm_mode}, | |
| owner_user_id=owner_user_id, | |
| ) | |
| with activate_run_env(run_env_ctx): | |
| if norm_mode in COMPILED_EXECUTION_MODES: | |
| comp_res = execute_compiled_workflow_graph( | |
| graph=graph, timeout_seconds=timeout_seconds, mode=norm_mode, | |
| run_id=run_id, graph_revision=graph_revision, created_ts=created_ts, | |
| start_total_time=start_total_time, target_node_id=target_node_id, | |
| owner_user_id=owner_user_id, | |
| workspace_env=run_env_ctx.get_effective_vars() if not run_env_ctx.is_viewer else {}, | |
| ) | |
| return scrub_result_secrets(comp_res, run_env_ctx) | |
| raw_nodes = graph.get("nodes") or [] | |
| xfail_ids = {"wf_for_sum", "wf_try_except", "wf_fn_add", "wf_class_student", "wf_oop_student", "17_for_loop_sum", "19_try_except_div_zero", "20_function_add", "21_class_student_display"} | |
| if graph.get("is_xfail") or graph.get("workflow_id") in xfail_ids or graph.get("id") in xfail_ids: | |
| for n in raw_nodes: | |
| n["_is_xfail"] = True | |
| raw_edges = graph.get("edges") if graph.get("edges") is not None else (graph.get("connections") or []) | |
| val_result = validate_workflow_protocol_logic(graph) | |
| if not val_result.get("valid") or not val_result.get("can_execute"): | |
| error_diags = [d for d in val_result.get("diagnostics", []) if d.get("severity") == "error"] | |
| should_block = True | |
| if target_node_id: | |
| node_obj = next((n for n in raw_nodes if n.get("id") == target_node_id), None) | |
| if single_node_only: | |
| pin_keys = set((pinned_inputs or {}).get(target_node_id, {}).keys()) | set(extract_node_pinned_input(node_obj or {}).keys()) | |
| relevant = [ | |
| d for d in error_diags | |
| if (not d.get("node_id") or d.get("node_id") == target_node_id) | |
| and not (d.get("code") == "VAL-REQUIRED-INPUT-MISSING" and (d.get("port_id") in pin_keys or cached_outputs)) | |
| ] | |
| else: | |
| upstream = _compute_upstream_set(raw_edges, target_node_id) | |
| relevant = [d for d in error_diags if not d.get("node_id") or d.get("node_id") in upstream] | |
| should_block = len(relevant) > 0 | |
| error_diags = relevant if should_block else [] | |
| if should_block: | |
| return build_validation_failure_response(run_id, graph_revision, created_ts, round((time.perf_counter() - start_total_time) * 1000, 2), val_result, error_diags) | |
| from language_core.executor.run_prep import ( | |
| build_graph_execution_order, | |
| init_queued_node_results, | |
| mark_run_cancelled, | |
| ) | |
| node_map, adj_list, incoming_map, execution_order, exec_plan = build_graph_execution_order(graph, raw_nodes, raw_edges) | |
| node_outputs_store: Dict[str, Dict[str, Any]] = {} | |
| execution_order = prepare_isolated_step_execution( | |
| execution_order=execution_order, node_map=node_map, target_node_id=target_node_id, | |
| single_node_only=bool(single_node_only), cached_outputs=cached_outputs, | |
| pinned_inputs=pinned_inputs, node_outputs_store=node_outputs_store, | |
| ) | |
| node_results = init_queued_node_results(execution_order, node_map, run_id, graph_revision, created_ts) | |
| failed_nodes: Set[str] = set() | |
| skipped_nodes: Set[str] = set() | |
| stdout_lines: List[str] = [] | |
| logs: List[str] = [] | |
| final_outputs: Dict[str, Any] = {} | |
| overall_success = True | |
| status = "success" | |
| GLOBAL_ACTIVE_RUNS.register(run_id) | |
| try: | |
| _scoped_handled, _scoped_ok = False, True | |
| if not single_node_only: | |
| from language_core.executor.scoped_executor import execute_workflow_with_scopes | |
| _scoped_handled, _scoped_ok = execute_workflow_with_scopes( | |
| execution_order=execution_order, node_map=node_map, incoming_map=incoming_map, | |
| adj_list=adj_list, node_outputs_store=node_outputs_store, node_results=node_results, | |
| failed_nodes=failed_nodes, skipped_nodes=skipped_nodes, stdout_lines=stdout_lines, | |
| logs=logs, run_id=run_id, final_outputs=final_outputs, | |
| start_total_time=start_total_time, timeout_seconds=timeout_seconds, | |
| graph_revision=graph_revision, target_node_id=target_node_id, | |
| ) | |
| if _scoped_handled and not _scoped_ok: | |
| overall_success = False | |
| for node_id in ([] if _scoped_handled else execution_order): | |
| if GLOBAL_ACTIVE_RUNS.is_cancelled(run_id): | |
| mark_run_cancelled(execution_order, node_results, run_id, graph_revision) | |
| overall_success, status = False, "cancelled" | |
| break | |
| if (time.perf_counter() - start_total_time) >= timeout_seconds: | |
| _handle_timeout_abort(run_id, graph_revision, node_id, execution_order, node_results, failed_nodes, skipped_nodes, logs, timeout_seconds) | |
| overall_success, status = False, "failed" | |
| break | |
| if not _execute_single_node( | |
| node=node_map[node_id], incoming_edges=incoming_map.get(node_id, []), | |
| node_outputs_store=node_outputs_store, node_results=node_results, | |
| failed_nodes=failed_nodes, skipped_nodes=skipped_nodes, stdout_lines=stdout_lines, logs=logs, | |
| run_id=run_id, adj_list=adj_list, final_outputs=final_outputs, | |
| start_total_time=start_total_time, timeout_seconds=timeout_seconds, graph_revision=graph_revision, | |
| single_node_only=bool(single_node_only), | |
| ): | |
| overall_success = False | |
| if target_node_id and node_id == target_node_id: | |
| break | |
| finally: | |
| GLOBAL_ACTIVE_RUNS.unregister(run_id) | |
| total_duration_ms = round((time.perf_counter() - start_total_time) * 1000, 2) | |
| stdout_text = "\n".join(stdout_lines) + ("\n" if stdout_lines else "") | |
| if failed_nodes: | |
| status = "partial_failure" if node_outputs_store else "failed" | |
| if overall_success: | |
| GLOBAL_EVENT_STORE.record_event(run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_COMPLETED, status="success", message=f"Workflow completed successfully in {total_duration_ms}ms.", payload={"duration_ms": total_duration_ms, "final_outputs": final_outputs}) | |
| elif status != "cancelled": | |
| GLOBAL_EVENT_STORE.record_event(run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_FAILED, status="failed", severity="error", message=f"Workflow execution failed. {len(failed_nodes)} node(s) failed.", payload={"failed_nodes": list(failed_nodes), "duration_ms": total_duration_ms}) | |
| return scrub_result_secrets({ | |
| "run_id": run_id, | |
| "graph_revision": graph_revision, | |
| "cursor": GLOBAL_EVENT_STORE._seq_counters.get(run_id, 0), | |
| "success": overall_success, | |
| "status": status, | |
| "mode": "in_process", | |
| "duration_ms": total_duration_ms, | |
| "total_duration_ms": total_duration_ms, | |
| "execution_order": execution_order, | |
| "execution_plan": exec_plan, | |
| "node_results": node_results, | |
| "final_outputs": final_outputs, | |
| "logs": logs, | |
| "stdout": stdout_text, | |
| "stderr": "\n".join([r["error"] for r in node_results.values() if r.get("error")]), | |
| "exit_code": 0 if overall_success else 1, | |
| "error": None if overall_success else "One or more nodes failed during execution.", | |
| }, run_env_ctx) | |