""" ALLI Codegen Subpackage: Strings, OOP & Dynamic Module Emitters. """ import ast import re from typing import Optional, Tuple from language_core.codegen_contracts import ( BANNED_IMPORTS, DANGEROUS_CALLABLES, DANGEROUS_SPECIAL_ATTRS, RESTRICTED_HOST_MODULES, SAFE_RUNTIME_STDLIB_MODULES, STANDARD_LIBS, format_literal, sanitize_identifier, ) from language_core.nodes.nodes_oop import _parse_class_attributes from lambdas.codegen.context import NodeCodegenCtx _IDENT_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$") def _is_safe_segment(seg: str) -> bool: return bool(_IDENT_RE.match(seg)) and seg not in RESTRICTED_HOST_MODULES and seg not in DANGEROUS_CALLABLES and not seg.startswith("__") def emit_string_and_oop_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg lines, ovm = cg.code_body_lines, cg.output_var_map if raw_type == "string.transform": txt_expr = nctx.resolve_input(["text", "text_in"], format_literal(params.get("text_in", params.get("text", "")))) nv = f"str_{safe_id}" op = str(params.get("operation", "upper")).lower() op = op if op in ("upper", "lower", "title", "strip", "capitalize", "swapcase") else "upper" lines.append(f" {nv} = {txt_expr}.{op}()") ovm.update({f"{node_id}:text_out": nv, f"{node_id}:result": nv, f"{node_id}:out": nv, f"{node_id}:length": f"len({nv})", node_id: nv}) return True, nv if raw_type == "string.concat": ae = nctx.resolve_input("a", format_literal(params.get("a", ""))) be = nctx.resolve_input("b", format_literal(params.get("b", ""))) sep, nv = params.get("separator", ""), f"concat_{safe_id}" lines.append(f" {nv} = str({ae}) + {format_literal(sep)} + str({be})" if sep else f" {nv} = str({ae}) + str({be})") ovm[f"{node_id}:length"] = f"len({nv})" return True, nv if raw_type == "string.split": txt_expr = nctx.resolve_input("text", format_literal(params.get("text", ""))) nv = f"split_{safe_id}" lines.append(f" {nv} = str({txt_expr}).split({format_literal(params.get('delimiter', ' '))})") ovm.update({f"{node_id}:items": nv, f"{node_id}:count": f"len({nv})"}) return True, nv if raw_type in ("oop.class_def", "class_def"): raw_cname = str(params.get("class_name", "Student")).strip() cname = sanitize_identifier(raw_cname, "Student") if not _IDENT_RE.match(cname) or cname.startswith("__"): cname = "Student" raw_attrs, attr_defaults = _parse_class_attributes(params.get("attributes", "name, score")) clean_attrs = [a for a in raw_attrs if _IDENT_RE.match(a) and not a.startswith("__") and a not in DANGEROUS_SPECIAL_ATTRS] attr_list = [sanitize_identifier(a) for a in clean_attrs] init_sig, has_def = [], False for raw_a, clean_a in zip(clean_attrs, attr_list): if raw_a in attr_defaults: has_def = True init_sig.append(f"{clean_a}={format_literal(attr_defaults[raw_a])}") else: init_sig.append(f"{clean_a}=None" if has_def else clean_a) sig_str = ", ".join(["self", *init_sig, "*_extra"]) if init_sig else "self, *_extra" nv = f"cls_{cname}_{safe_id}" doc = format_literal(str(params.get("docstring", "Class definition")).replace('"""', '')) lines.extend([f" class {cname}:", f" {doc}", f" def __init__({sig_str}):"]) lines.extend([f" self.{a} = {a}" for a in attr_list] if attr_list else [" pass"]) lines.append(f" {nv} = {cname}") ovm.update({f"{node_id}:class_ref": nv, f"{node_id}:class_name": format_literal(cname)}) return True, nv if raw_type in ("oop.instance", "instance"): cls_target = nctx.resolve_input("class_in", sanitize_identifier(params.get("class_name", "Student"), "Student")) arg1 = nctx.resolve_input("arg_1", format_literal(params.get("arg_1_val", "Alice"))) arg2 = nctx.resolve_input("arg_2", format_literal(params.get("arg_2_val", 85))) nv = f"inst_{safe_id}" lines.append(f" {nv} = {cls_target}({arg1}, {arg2})") ovm[f"{node_id}:instance"] = nv return True, nv if raw_type in ("oop.method_call", "method_call"): inst = nctx.resolve_input("instance_in", "self") mname = sanitize_identifier(params.get("method_name", "add_bonus"), "add_bonus") if not _IDENT_RE.match(mname) or mname.startswith("__"): mname = "add_bonus" raw_attr = str(params.get("attribute_to_modify", "score")).strip() if not _IDENT_RE.match(raw_attr) or raw_attr.startswith("__") or raw_attr in DANGEROUS_SPECIAL_ATTRS: raw_attr = "score" attr = raw_attr arg_val = nctx.resolve_input("arg", format_literal(params.get("default_arg", 15))) op = str(params.get("operation", "increment")).lower() nv = f"res_{safe_id}" if op in ("increment", "call_method"): lines.extend([ f" if hasattr({inst}, '{mname}'):", f" {nv} = {inst}.{mname}({arg_val})", " else:", f" setattr({inst}, '{attr}', getattr({inst}, '{attr}', 0) + {arg_val})", f" {nv} = getattr({inst}, '{attr}')", ]) elif op in ("set", "set_attr"): lines.extend([f" setattr({inst}, '{attr}', {arg_val})", f" {nv} = {arg_val}"]) else: lines.append(f" {nv} = getattr({inst}, '{attr}', None)") ovm.update({f"{node_id}:instance_out": inst, f"{node_id}:updated_instance": inst, f"{node_id}:result": nv, node_id: nv}) return True, nv return False, None def emit_module_and_fallback_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg lines, ovm = cg.code_body_lines, cg.output_var_map if raw_type in ("lang.import", "module.import", "core.import", "alli.lang.import", "alli.primitive.import", "alli.sys.import") or (raw_type.endswith(".import") and not raw_type.startswith("agent.")): mod = str(params.get("module_name") or "json").strip().lower() func_name, nv = str(params.get("function_name") or params.get("symbol") or "loads").strip(), f"res_{safe_id}" if mod in RESTRICTED_HOST_MODULES or mod not in SAFE_RUNTIME_STDLIB_MODULES: cg.diagnostics.append({"code": "CODEGEN-BANNED-MODULE", "severity": "error", "message": f"Restricted or unallowlisted module '{mod}' cannot be imported.", "node_id": node_id}) lines.append(f" {nv} = None") elif func_name and not _is_safe_segment(func_name): cg.diagnostics.append({"code": "CODEGEN-SECURITY-VIOLATION", "severity": "error", "message": f"Restricted or invalid symbol '{func_name}' for module '{mod}'.", "node_id": node_id}) lines.append(f" {nv} = None") else: cg.discovered_modules.add(mod) if mod not in STANDARD_LIBS: cg.discovered_requirements.add(mod) default_in = params.get("default_input") if params.get("default_input") is not None else ('{"name": "Alice", "score": 95}' if mod == "json" else (16 if func_name == "sqrt" else "None")) in_expr = nctx.resolve_input("data_in", nctx.resolve_input("in", nctx.resolve_input("payload", format_literal(default_in)))) if func_name: if func_name == "now" and mod == "datetime": lines.append(f" {nv} = datetime.datetime.now().isoformat()") else: lines.append(f" {nv} = {mod}.{func_name}({in_expr})" if (in_expr and in_expr != "None") else f" {nv} = {mod}.{func_name}()") else: nv = f"mod_{safe_id}" lines.append(f" {nv} = {mod}") ovm.update({f"{node_id}:result": nv, f"{node_id}:val": nv, f"{node_id}:out": nv, f"{node_id}:module_ref": format_literal(mod), node_id: nv}) return True, nv from lambdas.codegen.emitters_libraries import emit_python_library_preset_node handled_preset, preset_var = emit_python_library_preset_node(nctx) if handled_preset: return True, preset_var if "." in raw_type and not any(raw_type.startswith(f"{p}.") for p in BANNED_IMPORTS): parts = raw_type.split(".") mod, nv = parts[0], f"{parts[-1]}_{safe_id}" if mod in RESTRICTED_HOST_MODULES or not all(_is_safe_segment(p) for p in parts): cg.diagnostics.append({"code": "CODEGEN-BANNED-MODULE", "severity": "error", "message": f"Restricted module or symbol '{raw_type}' cannot be emitted.", "node_id": node_id}) lines.append(f" {nv} = None") return True, nv cg.discovered_modules.add(mod) if mod not in STANDARD_LIBS: cg.discovered_requirements.add(mod) arg_list = [ovm.get(f"{inc.get('source') or inc.get('from_node')}:{inc.get('source_handle') or inc.get('sourceHandle') or ''}") or ovm.get(str(inc.get("source") or inc.get("from_node"))) or "None" for inc in nctx.incoming] if nctx.incoming else [format_literal(v) for k, v in params.items() if k not in ("label", "node_type", "nodeType")] lines.append(f" {nv} = {raw_type}({', '.join(arg_list)})") return True, nv nv = sanitize_identifier(params.get("var_name"), f"step_{cg.step_counter}_{safe_id}") if nctx.incoming: lines.append(f" {nv} = {nctx.resolve_input('in', nctx.resolve_input('value', 'None'))}") else: lines.append(f" {nv} = {format_literal(params.get('value', params.get('literal_value', 'None')))}") return True, nv