rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download lambdas/codegen/scope_analysis.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 9.84 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/scope_analysis.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/lambdas/codegen/scope_analysis.py
-
curl -L -o scope_analysis.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/scope_analysis.py
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} | |