auto / lambdas /codegen /emitters_strings_oop.py
rsnarsna
feat(security,codegen): Wave 2-5 node standardization, SSRF & AST hardening (DEC-015)
a724795
Raw History Blame Contribute Delete
9.92 kB
"""
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