""" ALLI Graph Scope Analysis & Diamond-Merge Helpers. Shared by scoped Python codegen and scoped workflow runtime execution. """ import re from collections import defaultdict, deque from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple from language_core.codegen_contracts import sanitize_identifier TRUE_HANDLES = ("true", "then", "true_flow", "then_val") FALSE_HANDLES = ("false", "else", "false_flow", "else_val") BODY_HANDLES = ("body",) POST_LOOP_HANDLES = ("done", "completed") SAFE_SOURCE_TYPES = {"core.constant", "core.variable", "io.input", "oop.class_def", "data.list", "data.dict"} _ASSIGN_RE = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)") def norm_node_type(node: Dict[str, Any]) -> str: d = node.get("data") or {} return str(node.get("node_type") or node.get("type") or d.get("node_type") or d.get("nodeType") or "").strip().lower() def reachable_from(roots: Iterable[str], adj: Dict[str, List[str]]) -> Set[str]: seen: Set[str] = set() q = deque(roots) while q: cur = q.popleft() if cur in seen: continue seen.add(cur) for nxt in adj.get(cur, ()): if nxt not in seen: q.append(nxt) return seen def detect_scopes(node_map: Dict[str, Dict[str, Any]], edges: List[Dict[str, Any]]) -> Dict[str, Any]: out_edges: Dict[str, List[Tuple[str, str, str]]] = defaultdict(list) in_edges: Dict[str, List[Tuple[str, str, str]]] = defaultdict(list) adj: Dict[str, List[str]] = defaultdict(list) for e in edges: s = str(e.get("source") or e.get("from_node") or "") t = str(e.get("target") or e.get("to_node") or "") sh = str(e.get("source_handle") or e.get("sourceHandle") or e.get("from_port") or "").lower() th = str(e.get("target_handle") or e.get("targetHandle") or e.get("to_port") or "").lower() if s in node_map and t in node_map: out_edges[s].append((sh, t, th)) in_edges[t].append((s, sh, th)) adj[s].append(t) if_scopes, loop_scopes, try_scopes = {}, {}, {} for nid, node in node_map.items(): rt = norm_node_type(node) if rt in ("control.if_else", "if_else"): tr = [t for sh, t, _ in out_edges[nid] if sh in TRUE_HANDLES] fr = [t for sh, t, _ in out_edges[nid] if sh in FALSE_HANDLES] if tr or fr: r_t, r_f = reachable_from(tr, adj), reachable_from(fr, adj) merge = r_t & r_f if (r_t - merge) or (r_f - merge): if_scopes[nid] = {"only_true": r_t - merge, "only_false": r_f - merge, "merge": merge} elif rt in ("control.for_loop", "for_loop", "control.while_loop", "while_loop"): br = [t for sh, t, _ in out_edges[nid] if sh in BODY_HANDLES] if br: dr = [t for sh, t, _ in out_edges[nid] if sh in POST_LOOP_HANDLES] post = reachable_from(dr, adj) body = reachable_from(br, adj) - post - {nid} if body: loop_scopes[nid] = {"kind": "for" if "for" in rt else "while", "body": body} elif rt in ("control.try_except", "try_except"): inc = in_edges[nid] roots = {s for s, _, th in inc if th in ("try_val", "in", "value") or (not th and len(inc) == 1)} tset: Set[str] = set() q = deque(roots) while q: u = q.popleft() ut = norm_node_type(node_map[u]) if u in node_map else "" if not ut or u in tset or u == nid or ut in SAFE_SOURCE_TYPES or ut.startswith(("constant.", "trigger.")): continue if all(tgt in tset or tgt == nid for _, tgt, _ in out_edges[u]): tset.add(u) for ps, _, _ in in_edges[u]: q.append(ps) if tset: try_scopes[nid] = {"try_nodes": tset} return {"if": if_scopes, "loop": loop_scopes, "try": try_scopes, "in_edges": in_edges} def scope_children(nid: str, scopes: Dict[str, Any]) -> Set[str]: if nid in scopes["if"]: return scopes["if"][nid]["only_true"] | scopes["if"][nid]["only_false"] if nid in scopes["loop"]: return scopes["loop"][nid]["body"] if nid in scopes["try"]: return scopes["try"][nid]["try_nodes"] return set() def preinit_block_vars(cg: Any, header_idx: int, block_indent: str, skip_vars: Set[str]) -> None: new_vars: List[str] = [] seen = set(skip_vars) for line in cg.code_body_lines[:header_idx]: m = _ASSIGN_RE.match(line) if m and m.group(1) == block_indent: seen.add(m.group(2)) child_indent = block_indent + " " for line in cg.code_body_lines[header_idx:]: m = _ASSIGN_RE.match(line) if m and m.group(1).startswith(child_indent) and m.group(2) not in seen and m.group(2) != "return": seen.add(m.group(2)) new_vars.append(m.group(2)) if not new_vars: return init_lines = [f"{block_indent}{v} = None" for v in new_vars] cg.code_body_lines[header_idx:header_idx] = init_lines shift = len(init_lines) for sm in cg.source_map: if sm["line_start"] > header_idx: sm["line_start"] += shift sm["line_end"] += shift def build_merge_override(nid: str, cg: Any, inc_edges: List[Dict[str, Any]], completed_ifs: List[Tuple[str, str, Set[str], Set[str]]], indent: str, node: Optional[Dict[str, Any]] = None) -> Optional[List[Dict[str, Any]]]: ovm, grouped = cg.output_var_map, defaultdict(list) for e in inc_edges: th = str(e.get("target_handle") or e.get("targetHandle") or e.get("to_port") or "_default").lower() grouped[th].append(e) rewritten: Optional[List[Dict[str, Any]]] = None safe_m = sanitize_identifier(nid.replace("-", "_"), "m") np = node_params(node) if node else {} def _expr(ed: Dict[str, Any]) -> str: sid = str(ed.get("source") or ed.get("from_node")) sh = str(ed.get("source_handle") or ed.get("sourceHandle") or ed.get("from_port") or "") return ovm.get(f"{sid}:{sh}") or ovm.get(f"{sid}:result") or ovm.get(f"{sid}:out") or ovm.get(sid) or "None" for if_id, branch_var, only_t, only_f in completed_ifs: def _is_t(e: Dict[str, Any]) -> bool: s, sh = str(e.get("source") or e.get("from_node")), str(e.get("source_handle") or e.get("sourceHandle") or "").lower() return s in only_t or (s == if_id and sh in TRUE_HANDLES) def _is_f(e: Dict[str, Any]) -> bool: s, sh = str(e.get("source") or e.get("from_node")), str(e.get("source_handle") or e.get("sourceHandle") or "").lower() return s in only_f or (s == if_id and sh in FALSE_HANDLES) for th, elist in grouped.items(): t_e = next((e for e in elist if _is_t(e)), None) f_e = next((e for e in elist if _is_f(e)), None) if not (t_e or f_e): continue if t_e and f_e: cond_rhs = f"({_expr(t_e)} if {branch_var} else {_expr(f_e)})" else: fb = repr(np[th]) if th in np and np[th] is not None else ("0" if norm_node_type(node or {}) in ("core.binary_op", "primitive.binary_op") else "None") cond_rhs = f"({_expr(t_e)} if {branch_var} else {fb})" if t_e else f"({fb} if {branch_var} else {_expr(f_e)})" mvar = f"_merge_{safe_m}_{sanitize_identifier(th, 'v')}" cg.code_body_lines.append(f"{indent}{mvar} = {cond_rhs}") ovm[f"_phi_{nid}:{th}"] = mvar if rewritten is None: rewritten = list(inc_edges) rewritten = [e for e in rewritten if e not in ([t_e] if t_e else []) and e not in ([f_e] if f_e else [])] rewritten.append({"source": f"_phi_{nid}", "source_handle": th, "target": nid, "target_handle": "" if th == "_default" else th}) return rewritten CMP_OPS: Dict[str, Callable[[Any, Any], bool]] = { "<": lambda a, b: a < b, "<=": lambda a, b: a <= b, ">": lambda a, b: a > b, ">=": lambda a, b: a >= b, "==": lambda a, b: a == b, "!=": lambda a, b: a != b, } def node_params(node: Dict[str, Any]) -> Dict[str, Any]: d = node.get("data") or {} return {**(d if isinstance(d, dict) else {}), **(node.get("parameters") or {}), **(d.get("parameters") or {})} def match_catch_type(catch_type: str, err_msg: str) -> bool: ct, low = (catch_type or "Exception").strip(), err_msg.lower() if ct in ("Exception", "BaseException", "") or ct in err_msg or ct.lower() in low: return True if ct == "ZeroDivisionError" and any(k in low for k in ("zero", "math-e001", "division")): return True return ct == "ValueError" and any(k in low for k in ("domain", "math-e002", "value")) def reset_sub_nodes(nodes: Set[str], store: Dict[str, Dict[str, Any]], skipped: Set[str], failed: Set[str]) -> None: for n in nodes: store.pop(n, None) skipped.discard(n) failed.discard(n) def mark_skipped(nodes: Set[str], node_map: Dict[str, Any], skipped: Set[str], results: Dict[str, Dict[str, Any]], reason: str = "INFO-BRANCH-SKIPPED", skip_msg: Optional[str] = None) -> None: msg = skip_msg or f"Skipped ({reason})." for nid in nodes: skipped.add(nid) entry = results.setdefault(nid, {"node_id": nid, "node_type": norm_node_type(node_map.get(nid, {})), "outputs": {}, "duration_ms": 0.0}) entry["status"] = "skipped" entry["exec_state"] = "skipped" if not entry.get("skip_reason"): entry["skip_reason"] = msg if not entry.get("error_semantics"): entry["error_semantics"] = {"code": reason, "severity": "info", "message": msg}