File size: 9,922 Bytes
a724795 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | """
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
|