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