rsnarsna
feat(runtime): enable preset library execution and sanitize validation checks (DEC-019)
ee7ac62 Download lambdas/validation/node_checks.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 18.2 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/validation/node_checks.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/lambdas/validation/node_checks.py
-
curl -L -o node_checks.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/validation/node_checks.py
18.2 kB
| """ | |
| ALLI Validation Subpackage: Per-Node Schema, Required Ports & Parameter Validation. | |
| """ | |
| from typing import Any, Callable, Dict, List, Set | |
| from language_core.core_nodes_generated import CORE_PARAM_ALIASES, CORE_PORT_ALIASES | |
| from language_core.input_transforms import find_transform_for_port, get_node_input_transforms, validate_input_transforms_config | |
| from language_core.node_schema import default_registry, get_effective_node_schema | |
| from language_core.parameter_validator import ( | |
| is_non_finite_number, | |
| validate_parameter_value, | |
| validate_python_identifier, | |
| ) | |
| from library_inspector.node_synthesizer import global_staging_registry | |
| from lambdas.validation.security_checks import validate_node_security_and_deps | |
| from lambdas.validation.types_and_expr import is_configured_port_value, validate_expression_logic | |
| KNOWN_PREFIXES = ( | |
| "cat_", "cat.", "fundamentals.", "alli.primitive.", "alli.func.", "alli.oop.", "alli.sys.", "alli.agent.", "alli.lang.", | |
| "primitive.", "func.", "oop.", "sys.", "agent.", "constant.", "control.", "io.", "math.", "core.", "operator.", "workflow.", "trigger.", "api.", "file.", "json.", "csv.", "data.", "lang.", "module.", "db.", | |
| ) | |
| KNOWN_EXACT_TYPES = { | |
| "variable", "constant", "binary_op", "operator", "math", "input", "output", "display.output", "print", "print_output", "if_else", "condition", "control.branch", "control.if_else", "for_loop", "while_loop", "loop", "function", "function.def", "function.call", "class", "class_def", "try_except", "try_catch", "start", "workflow_group", "system.workflow_group", "group", "webhook", "schedule", "manual_trigger", "text_prompt", "file_input", "http_request", "response_json", "api_response", "lang.import", "module.import", "core.import", "core.scope", "db.query", "sys.file", "numpy.array", "pandas.dataframe", "requests.get", "statistics.mean", "alli.sys.import", "alli.sys.env", "alli.primitive.datetime", | |
| } | |
| def resolve_inputs_for_node(n: Dict[str, Any]) -> List[Dict[str, Any]]: | |
| d = n.get("data", {}) | |
| ntype = str(n.get("node_type") or n.get("type") or d.get("node_type") or "") | |
| reg_schema = get_effective_node_schema(ntype) | |
| if reg_schema: | |
| return [ | |
| {"id": p.id, "name": p.name, "type": p.type, "required": p.required, "default_value": p.default_value} | |
| for p in reg_schema.inputs | |
| ] | |
| spec = d.get("spec", {}) | |
| inputs = spec.get("inputs") or d.get("inputs") or n.get("inputs") | |
| if inputs and isinstance(inputs, list): | |
| return inputs | |
| t, lbl = ntype.lower(), str(d.get("label") or "").lower() | |
| if "constant" in t or t.startswith("constant.") or t in ("input", "constant"): | |
| return [] | |
| if "math.sqrt" in t or "sqrt" in lbl: | |
| return [{"id": "x", "name": "x", "type": "float", "required": True}] | |
| if "binary" in t or "calc" in lbl or "add" in lbl or "operator" in t: | |
| return [{"id": "a", "name": "a", "type": "any", "required": True}, {"id": "b", "name": "b", "type": "any", "required": True}] | |
| if "if" in t or ("condition" in lbl and "true" not in lbl and "false" not in lbl): | |
| return [{"id": "condition", "name": "condition", "type": "bool", "required": True}] | |
| if "print" in t or "display" in t or "io.print" in t: | |
| return [{"id": "value", "name": "value", "type": "any", "required": True}] | |
| if "for_loop" in t: | |
| return [{"id": "iterable", "name": "iterable", "type": "any", "required": True}] | |
| if "while_loop" in t: | |
| return [{"id": "condition", "name": "condition", "type": "bool", "required": True}] | |
| return [] | |
| def is_known_node_type(ntype: str, graph_deps: Set[str], std_libs: Set[str]) -> bool: | |
| t = ntype.lower().strip() | |
| if not t: | |
| return False | |
| if default_registry.get(t) or any(t.startswith(p) for p in KNOWN_PREFIXES) or t in KNOWN_EXACT_TYPES or t in graph_deps or t in std_libs: | |
| return True | |
| if "." in t: | |
| mod = t.split(".")[0].lower() | |
| return mod in std_libs or mod in ("alli", "system", "primitive", "constant", "control", "io", "math", "custom", "display", "core", "operator", "lang", "module", "data", "agent", "db", "sys") or mod in graph_deps | |
| return False | |
| def _validate_schema_and_staging(nid: str, ntype: str, label: str, n: Dict[str, Any], d: Dict[str, Any], graph_deps: Set[str], std_libs: Set[str], add_diag: Callable[..., None]) -> None: | |
| node_schema_obj = get_effective_node_schema(ntype) | |
| staged_rec = global_staging_registry.get_record(ntype) if global_staging_registry.has(ntype) else None | |
| node_caps = None | |
| if node_schema_obj: | |
| node_caps = getattr(node_schema_obj, "capability_states", None) or getattr(getattr(node_schema_obj, "verification", None), "capability_states", None) | |
| if hasattr(node_caps, "model_dump"): | |
| node_caps = node_caps.model_dump() | |
| if not node_caps: | |
| node_caps = ( | |
| d.get("capability_states") | |
| or n.get("capability_states") | |
| or (n.get("parameters") or {}).get("capability_states") | |
| or (d.get("verification") or {}).get("capability_states") | |
| or (staged_rec.capability_states if staged_rec else None) | |
| ) | |
| if default_registry.has(ntype) and default_registry.has_executor(ntype): | |
| return | |
| if node_caps and node_caps.get("runtime_supported") is False and ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"): | |
| add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Unsupported: Node '{label}' ({nid}) of type '{ntype}' is marked runtime_supported=False and cannot be executed in the runtime engine.", 8, node_id=nid, fix="Use a runtime-supported node implementation or export python code for external execution.") | |
| elif staged_rec and staged_rec.is_supported is False and ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"): | |
| add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Unsupported: Staged node '{label}' ({nid}) of type '{ntype}' contains unsupported types or security violations.", 8, node_id=nid, fix="Ensure all port types are supported and security constraints are satisfied.") | |
| elif global_staging_registry.has(ntype) and not global_staging_registry.is_approved(ntype) and not default_registry.has(ntype) and ntype != "requests.get": | |
| add_diag("error", "Execution Validation", "RULE-NODE-STAGED-UNAPPROVED", f"Unapproved Staged Node: Node '{label}' ({nid}) uses introspected staged schema '{ntype}' which has not been authorized for production execution.", 8, node_id=nid, fix="An authorized administrator must approve this staged node before workflow execution.") | |
| elif global_staging_registry.has(ntype) and global_staging_registry.is_approved(ntype) and not default_registry.has(ntype): | |
| if ntype not in ("requests.get", "statistics.mean", "alli.primitive.datetime"): | |
| add_diag("error", "Execution Validation", "EXEC_UNSUPPORTED", f"[VAL-UNSUPPORTED-RUNTIME] Execution Handler Missing: Approved staged node '{label}' ({nid}) of type '{ntype}' has no registered execution handler in runtime registry.", 8, node_id=nid, fix="Register an executable callable handler for this staged node in the execution registry.") | |
| elif not is_known_node_type(ntype, graph_deps, std_libs): | |
| add_diag("error", "Node Validation", "VAL-UNKNOWN-NODE-TYPE", f"Unregistered Node Type: Node '{label}' ({nid}) specifies unknown type '{ntype}' with no registered execution handler.", 2, node_id=nid, fix="Select a valid standard node schema from the library palette or register its definition.") | |
| def _validate_required_inputs(nid: str, ntype: str, label: str, n: Dict[str, Any], node_incoming: List[Dict[str, Any]], combined_params: Dict[str, Any], add_diag: Callable[..., None]) -> None: | |
| input_defs = resolve_inputs_for_node(n) | |
| data_port_aliases = {"in", "input", "value", "val", "data", "text", "x", "collection", "items", "args"} | |
| single_req = len(input_defs) == 1 or len([i for i in input_defs if i.get("required")]) == 1 | |
| node_aliases = CORE_PORT_ALIASES.get(ntype.lower(), {}).get("inputs", {}) | |
| for inp in input_defs: | |
| if not inp.get("required", False): | |
| continue | |
| port_id = inp.get("id") or inp.get("name") | |
| port_name = inp.get("name") or port_id | |
| pid_low, pname_low = str(port_id).lower(), str(port_name).lower() | |
| is_data_port = pid_low in data_port_aliases or pname_low in data_port_aliases | |
| def _wire_matches(e: Dict[str, Any]) -> bool: | |
| tgt = str(e.get("targetHandle") or e.get("to_port") or e.get("target_handle") or "").strip().lower() | |
| if tgt in (pid_low, pname_low): | |
| return True | |
| canon = node_aliases.get(tgt) | |
| if canon and canon.lower() in (pid_low, pname_low): | |
| return True | |
| if (not tgt or (is_data_port and tgt in data_port_aliases)) and single_req: | |
| return True | |
| if pid_low == "value" and tgt in ("in", "input", "val", "data"): | |
| return True | |
| return pid_low == "in" and tgt in ("value", "input", "val", "data") | |
| has_wire = any(_wire_matches(e) for e in node_incoming) | |
| port_type = str(inp.get("type") or inp.get("type_hint") or "any") | |
| alias_keys = [ak for ak, av in node_aliases.items() if str(av).lower() in (pid_low, pname_low)] | |
| param_aliases = CORE_PARAM_ALIASES.get(ntype.lower(), {}) | |
| alias_keys.extend(ak for ak, av in param_aliases.items() if str(av).lower() in (pid_low, pname_low)) | |
| check_keys = [port_id, port_name, f"param_{port_id}", f"param_{port_name}", *alias_keys] | |
| has_val = any(k in combined_params and is_configured_port_value(combined_params[k], expected_type=port_type) for k in check_keys) | |
| if not has_val: | |
| t_cfg = find_transform_for_port(get_node_input_transforms(n, n.get("data"), combined_params), [port_id, port_name], ntype) | |
| if t_cfg and t_cfg.get("fallback") is not None: | |
| has_val = True | |
| if not has_val and inp.get("default_value") is not None: | |
| has_val = is_configured_port_value(inp["default_value"], expected_type=port_type) | |
| if not has_wire and not has_val: | |
| add_diag("error", "Data Validation", "VAL-REQUIRED-INPUT-MISSING", f"Required Input Missing: Port '{port_id}' on node '{label}' ({nid}) is required but unconnected and has no configured value.", 6, node_id=nid, port_id=port_id, fix=f"Connect an output wire to port '{port_id}' or provide a parameter value in the configuration drawer.") | |
| def validate_all_nodes( | |
| nodes: List[Dict[str, Any]], | |
| incoming_map: Dict[str, List[Dict[str, Any]]], | |
| graph_deps: Set[str], | |
| std_libs: Set[str], | |
| add_diag: Callable[..., None], | |
| ) -> None: | |
| """Validate every node's schema, required inputs, parameter constraints, expressions, and security.""" | |
| for n in nodes: | |
| nid = n.get("id") | |
| d = n.get("data", {}) if isinstance(n.get("data"), dict) else {} | |
| custom = d.get("customData") if isinstance(d.get("customData"), dict) else {} | |
| top_params = n.get("parameters") if isinstance(n.get("parameters"), dict) else (n.get("params") if isinstance(n.get("params"), dict) else {}) | |
| params = d.get("parameters") if isinstance(d.get("parameters"), dict) else (d.get("params") if isinstance(d.get("params"), dict) else {}) | |
| values = d.get("values") if isinstance(d.get("values"), dict) else {} | |
| inputs_dict = n.get("inputs") if isinstance(n.get("inputs"), dict) else (d.get("inputs") if isinstance(d.get("inputs"), dict) else {}) | |
| combined = {**d, **custom, **values, **inputs_dict, **params, **top_params} | |
| ntype = str(n.get("node_type") or n.get("type") or d.get("node_type") or d.get("nodeType") or "") | |
| label = str(d.get("label") or ntype or "Node") | |
| _validate_schema_and_staging(nid, ntype, label, n, d, graph_deps, std_libs, add_diag) | |
| _validate_required_inputs(nid, ntype, label, n, incoming_map.get(nid, []), combined, add_diag) | |
| if "binary" in ntype.lower() or "calc" in label.lower() or "operator" in ntype.lower(): | |
| if (combined.get("operator") or "+") in ("/", "//", "%") and combined.get("b") in (0, "0"): | |
| add_diag("error", "Expression Validation", "MATH-E001", f"ZeroDivisionError: Division or modulo by literal zero in node '{label}' ({nid}).", 4, node_id=nid, port_id="b", fix="Operand B cannot be zero for division ('/') or modulo ('%').") | |
| if "sqrt" in ntype.lower() or "sqrt" in label.lower(): | |
| x_val = combined.get("x") | |
| if x_val is not None and x_val != "": | |
| try: | |
| if float(x_val) < 0: | |
| add_diag("error", "Expression Validation", "MATH-E002", f"Math Domain Error: Node '{label}' ({nid}) receives negative literal {x_val} for square root.", 4, node_id=nid, port_id="x", fix="Square root requires a non-negative number (x >= 0).") | |
| except ValueError: | |
| pass | |
| if ntype in ("core.type_cast", "type_cast", "custom.type_cast") or "type_cast" in str(ntype).lower(): | |
| from language_core.executor.wave1_handlers import normalize_cast_target, strict_cast_value | |
| raw_ttype = combined.get("target_type") | |
| if raw_ttype not in (None, ""): | |
| try: | |
| clean_ttype = normalize_cast_target(raw_ttype) | |
| except ValueError as ve: | |
| add_diag("error", "Data Validation", "VAL-PARAM-CONSTRAINT", str(ve), 6, node_id=nid, port_id="target_type", fix="Choose one of int, float, str, bool, list, dict, json.") | |
| clean_ttype = None | |
| if clean_ttype and combined.get("value") not in (None, ""): | |
| try: | |
| strict_cast_value(combined["value"], clean_ttype) | |
| except ValueError: | |
| add_diag("error", "Data Validation", "ERR-TYPE-CAST", f"Type Cast Error: Cannot cast literal '{combined['value']}' to {clean_ttype} on node '{label}' ({nid}).", 6, node_id=nid, port_id="value", fix=f"Provide a valid {clean_ttype} literal.") | |
| if ntype in ("sys.env_get", "sys.env_set", "alli.sys.env", "sys.env"): | |
| from language_core.workspace_env_contracts import validate_env_key | |
| raw_env_key = combined.get("key") | |
| if raw_env_key not in (None, ""): | |
| ok_env, code_env, err_env = validate_env_key(raw_env_key) | |
| if not ok_env: | |
| add_diag("error", "Security", code_env, err_env, 6, node_id=nid, port_id="key", fix="Use a non-reserved UPPER_SNAKE_CASE environment key (e.g. APP_MODE).") | |
| if ntype in ("function.call", "func.call"): | |
| has_wire = any(str(e.get("target_handle") or e.get("targetHandle") or "").lower() in ("arg", "arg_1", "args", "value") for e in incoming_map.get(nid, [])) | |
| if not has_wire and combined.get("arg") in (None, ""): | |
| add_diag("error", "Data Validation", "ERR-ARG-MISSING", f"Function call on node '{label}' ({nid}) port 'arg' is missing required argument.", 6, node_id=nid, port_id="arg", fix="Connect an argument to port 'arg' or configure it in the parameters.") | |
| for pk, pv in combined.items(): | |
| found_nf, tok_nf = is_non_finite_number(pv) | |
| if found_nf: | |
| add_diag("error", "Node Validation", "VAL-PARAM-NON-FINITE", f"Non-Finite Number Error: Parameter '{pk}' on node '{label}' ({nid}) contains non-finite numeric value '{tok_nf}' (NaN or Infinity). Only finite numeric values are permitted.", 2, node_id=nid, port_id=pk, fix=f"Replace '{tok_nf}' with a valid finite number.") | |
| validated_param_ids: Set[str] = set() | |
| node_schema = get_effective_node_schema(ntype) | |
| if node_schema and node_schema.parameters: | |
| for param in node_schema.parameters: | |
| validated_param_ids.add(param.id) | |
| pval = combined[param.id] if param.id in combined else (custom[param.id] if param.id in custom else (combined[f"param_{param.id}"] if f"param_{param.id}" in combined else param.default)) | |
| p_valid, p_code, p_msg, p_fix = validate_parameter_value(param, pval, node_label=label, node_id=nid) | |
| if not p_valid: | |
| add_diag("error", "Node Validation", p_code or "VAL-PARAM-CONSTRAINT", p_msg or f"Parameter '{param.name}' violates declared schema constraint.", 2, node_id=nid, port_id=param.id, fix=p_fix) | |
| is_var_or_const = "variable" in ntype.lower() or "constant" in ntype.lower() | |
| for id_field in ("var_name", "variable_name", "const_name", "func_name", "fn_name", "function_name", "class_name", "loop_var", "iter_var", "target_var"): | |
| if id_field in combined and (id_field not in validated_param_ids or (is_var_or_const and id_field == "const_name")): | |
| if id_field in ("var_name", "variable_name", "const_name") and not is_var_or_const: | |
| continue | |
| if combined[id_field] is not None: | |
| ok, code, msg, fix = validate_python_identifier(combined[id_field], field_id=id_field) | |
| if not ok: | |
| add_diag("error", "Node Validation", code or "COMP-E101", f"{msg} on node '{label}' ({nid}).", 2, node_id=nid, port_id=id_field, fix=fix) | |
| if "condition" in combined or "if" in ntype.lower(): | |
| cond = str(combined.get("condition") or "True") | |
| expr_res = validate_expression_logic(cond) | |
| if not expr_res.get("valid"): | |
| add_diag("error", "Expression Validation", "COMP-E102", f"Syntax error in condition expression '{cond}': {expr_res.get('error')}", 4, node_id=nid, port_id="condition", fix="Check for balanced parentheses, quotes, and valid Python syntax.") | |
| validate_input_transforms_config(combined.get("_input_transforms"), label, nid, add_diag) | |
| validate_node_security_and_deps(nid, ntype, label, combined, graph_deps, std_libs, add_diag) | |