auto / lambdas /codegen /scope_analysis.py
rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98
Raw History Blame Contribute Delete
9.84 kB
"""
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}