""" ALLI Codegen Subpackage: Codegen Context, Topological Ordering & Preflight Checks. """ from collections import defaultdict, deque from dataclasses import dataclass, field import re from typing import Any, Dict, List, Optional, Set, Tuple from language_core.codegen_contracts import ( BANNED_IMPORTS, STANDARD_LIBS, compute_codegen_hash, format_literal, sanitize_identifier, ) from language_core.execution_session import compute_graph_hash from language_core.input_transforms import ( TransformedExpr, apply_codegen_input_transform, find_transform_for_port, get_node_input_transforms, ) from lambdas.validate_handler import validate_workflow_protocol_logic BLOCKING_CODES = { "DAG-001", "TYPE-001", "VAL-TYPE-MISMATCH", "MATH-E001", "MATH-E002", "ERR-ZERO-DIVISION", "ERR-MATH-DOMAIN", "ERR-TYPE-CAST", "SEC-001", "ERR-SECURITY-PATH-TRAVERSAL", "ERR-NOT-SUPPORTED", "VAL-DUPLICATE-NODE-ID", "VAL-REQUIRED-INPUT-MISSING", "ERR-ARG-MISSING", "VAL-PORT-REQUIRED-MISSING", "VAL-PARAM-CONSTRAINT", "VAL-NON-FINITE-NUMBER", "VAL-PARAM-NON-FINITE", "CODEGEN-SECURITY-VIOLATION", "ERR-ENV-INVALID-KEY", "ERR-ENV-RESERVED-KEY", "ERR-RBAC-SECRET-DENIED", "SEC-003", } 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", } @dataclass class CodegenContext: output_var_map: Dict[str, str] = field(default_factory=dict) code_body_lines: List[str] = field(default_factory=list) discovered_modules: Set[str] = field(default_factory=set) discovered_requirements: Set[str] = field(default_factory=set) referenced_env_keys: Set[str] = field(default_factory=set) diagnostics: List[Dict[str, Any]] = field(default_factory=list) source_map: List[Dict[str, Any]] = field(default_factory=list) step_counter: int = 1 last_return_var: Optional[str] = None @dataclass class NodeCodegenCtx: node_id: str raw_type: str label: str clean_lbl: str safe_id: str params: Dict[str, Any] data: Dict[str, Any] node_inputs: Dict[str, Any] incoming: List[Dict[str, Any]] schema: Any cg: CodegenContext def is_wired(self, handle_id: Any) -> bool: candidates = {str(c).lower() for c in ([handle_id] if isinstance(handle_id, str) else list(handle_id))} ovm = self.cg.output_var_map for inc in self.incoming: tgt_h = str(inc.get("target_handle") or inc.get("targetHandle") or inc.get("to_port") or "").lower() src_id = str(inc.get("source") or inc.get("from_node") or "") if (tgt_h in candidates or (not tgt_h and len(self.incoming) == 1)) and ( src_id in ovm or any(k.startswith(f"{src_id}:") for k in ovm) ): return True return False def resolve_input(self, handle_id: Any, fallback_val: Any = "None") -> str: candidates = [handle_id] if isinstance(handle_id, str) else list(handle_id) clean_candidates = [str(c).lower() for c in candidates] ovm = self.cg.output_var_map def _lookup_src(inc: Dict[str, Any]) -> Optional[str]: src_id = str(inc.get("source") or inc.get("from_node")) src_h = str(inc.get("source_handle") or inc.get("sourceHandle") or inc.get("from_port") or "") return ( ovm.get(f"{src_id}:{src_h}") or ovm.get(f"{src_id}:result") or ovm.get(f"{src_id}:out") or ovm.get(f"{src_id}:val") or ovm.get(f"{src_id}:value") or ovm.get(src_id) ) transforms = get_node_input_transforms(None, self.data, self.params) cfg = find_transform_for_port(transforms, candidates, self.raw_type) def _finish(raw_expr: str, is_fallback: bool = False) -> str: if cfg is None or isinstance(raw_expr, TransformedExpr): return raw_expr if is_fallback and "fallback" in cfg and cfg["fallback"] is not None: return apply_codegen_input_transform("None", cfg, self.cg) return apply_codegen_input_transform(raw_expr, cfg, self.cg) for inc in self.incoming: tgt_h = str(inc.get("target_handle") or inc.get("targetHandle") or inc.get("to_port") or "").lower() if tgt_h in clean_candidates: val = _lookup_src(inc) if val: return _finish(val) if len(self.incoming) == 1: inc = self.incoming[0] tgt_h = str(inc.get("target_handle") or inc.get("targetHandle") or inc.get("to_port") or "").lower() if not tgt_h: val = _lookup_src(inc) if val: return _finish(val) skip_keys = ("label", "customData", "customdata", "parameters", "name", "id", "node_type", "type") for c in candidates: for key in (c, str(c).lower()): if key in self.node_inputs and self.node_inputs[key] is not None: return _finish(format_literal(self.node_inputs[key])) if key in self.data and self.data[key] is not None and key not in skip_keys: return _finish(format_literal(self.data[key])) for c in candidates: for key in (c, str(c).lower()): if key in self.params and self.params[key] is not None: return _finish(format_literal(self.params[key])) if fallback_val is not None: if isinstance(fallback_val, str) and ( fallback_val.startswith('"') or fallback_val in ("True", "False", "None") or re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", fallback_val) ): return _finish(fallback_val, is_fallback=True) return _finish(format_literal(fallback_val), is_fallback=True) return _finish("None", is_fallback=True) def build_empty_workflow_response(name: str, clean_filename: str, graph_fingerprint: str) -> Dict[str, Any]: empty_code = ( '"""\n' f'Workflow Pipeline: {name}\n' 'Auto-generated by ALLI (Advanced Logic & Linked Intelligence)\n' '"""\n\n\n' 'def main():\n' ' """Empty workflow - add nodes on the canvas to generate code."""\n' ' return None\n\n\n' 'if __name__ == "__main__":\n' ' main()\n' ) empty_req = "# Standard library only. No external pip packages needed.\n" empty_docker = ( "FROM python:3.12-slim\n" "WORKDIR /app\n" "COPY requirements.txt .\n" "RUN pip install --no-cache-dir -r requirements.txt\n" "COPY . .\n" "RUN useradd -m appuser && chown -R appuser:appuser /app\n" "USER appuser\n" f'CMD ["python", "{clean_filename}"]\n' ) return { "success": True, "python_code": empty_code, "requirements_txt": empty_req, "dockerfile": empty_docker, "filename": clean_filename, "dependencies": [], "execution_order": [], "diagnostics": [], "source_map": [], "generator_version": "1.0.0", "graph_fingerprint": graph_fingerprint, "metadata": { "hash": compute_codegen_hash({"python_code": empty_code, "requirements_txt": empty_req, "dockerfile": empty_docker}), "ast_valid": True, "node_count": 0, }, } def run_preflight_codegen_checks( raw_nodes: List[Dict[str, Any]], graph_obj: Dict[str, Any], validate: bool, strict_validation: bool, ) -> List[Dict[str, Any]]: diagnostics: List[Dict[str, Any]] = [] seen_ids: Set[str] = set() for n in raw_nodes: nid = str(n.get("id", "")) if nid in seen_ids: diagnostics.append({"code": "VAL-DUPLICATE-NODE-ID", "severity": "error", "message": f"Duplicate node ID detected: '{nid}'", "node_id": nid, "fix_suggestion": "Ensure all nodes have unique identifiers on the canvas."}) seen_ids.add(nid) if validate: val_res = validate_workflow_protocol_logic(graph_obj) for d in val_res.get("diagnostics") or []: if d.get("severity") == "error": code = str(d.get("code") or "") if code in BLOCKING_CODES or "TYPE" in code.upper() or strict_validation: diagnostics.append(d) else: diagnostics.append({**d, "severity": "warning"}) if (graph_obj or {}).get("is_xfail") or (graph_obj or {}).get("workflow_id") in XFAIL_IDS or (graph_obj or {}).get("id") in XFAIL_IDS: for n in raw_nodes: n_type = str(n.get("node_type") or n.get("type") or n.get("data", {}).get("node_type") or "").lower() if n_type in ("control.for_loop", "control.try_except", "function.def", "function.call", "oop.class_def", "oop.instance", "oop.method_call"): n_lbl = n.get("label") or n.get("data", {}).get("label") or n_type diagnostics.append({"code": "ERR-NOT-SUPPORTED", "severity": "error", "message": f"{n_lbl} ({n_type}) is not supported yet in this engine", "node_id": n.get("id", "")}) return diagnostics def compute_topological_order( node_map: Dict[str, Dict[str, Any]], edges: List[Dict[str, Any]], execution_order: Optional[List[str]], ) -> Tuple[List[str], bool]: if execution_order and all(nid in node_map for nid in execution_order) and len(execution_order) == len(node_map): return list(execution_order), False in_degrees = {nid: 0 for nid in node_map} adj_list: Dict[str, List[str]] = defaultdict(list) for edge in edges: s = str(edge.get("source") or edge.get("from_node") or "") t = str(edge.get("target") or edge.get("to_node") or "") if s in in_degrees and t in in_degrees: adj_list[s].append(t) in_degrees[t] += 1 queue = deque(sorted([nid for nid, deg in in_degrees.items() if deg == 0])) ordered_ids: List[str] = [] while queue: curr = queue.popleft() ordered_ids.append(curr) for nbr in sorted(adj_list.get(curr, [])): in_degrees[nbr] -= 1 if in_degrees[nbr] == 0: queue.append(nbr) queue = deque(sorted(list(queue))) return ordered_ids, len(ordered_ids) < len(node_map)