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