monkeybrain-runtime 1.0.0__py3-none-any.whl

services/process_definitions/node_services/functions.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from services.process_definitions.node_services.models import (
+    NodeExecutionResult,
+    coerce_config_value,
+    config_value,
+    delete_nested_value,
+    nested_value,
+    payload_message,
+    rule_matches,
+    set_nested_value,
+)
+
+
+def _node_red_value_type(value: Any) -> str:
+    aliases = {
+        "str": "string",
+        "num": "number",
+        "bool": "boolean",
+    }
+    normalized = str(value or "json").strip().lower()
+    return aliases.get(normalized, normalized)
+
+
+async def execute_function_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    message = dict(payload)
+    if node_type == "change":
+        for rule in config.get("rules") or []:
+            if not isinstance(rule, dict):
+                continue
+            operation = str(rule.get("operation") or rule.get("op") or rule.get("t") or "set").lower()
+            prop = str(rule.get("property") or rule.get("p") or "")
+            value = rule.get("value") if "value" in rule else rule.get("to")
+            value_type = rule.get("value_type") or rule.get("tot")
+            if operation == "set":
+                set_nested_value(message, prop, coerce_config_value(value, value_type))
+            elif operation in {"delete", "del"}:
+                delete_nested_value(message, prop)
+            elif operation in {"move", "mov"}:
+                target = str(rule.get("target") or rule.get("to") or "")
+                moved = nested_value(message, prop)
+                delete_nested_value(message, prop)
+                set_nested_value(message, target, moved)
+        return NodeExecutionResult(True, None, {"status": "changed", "message": message})
+    if node_type == "switch":
+        prop = str(config_value(config, "property", "payload"))
+        actual = nested_value(message, prop)
+        matched = []
+        for index, rule in enumerate(config.get("rules") or []):
+            if isinstance(rule, dict) and rule_matches(actual, rule):
+                matched.append(index)
+                if not bool(config.get("check_all", True)):
+                    break
+        return NodeExecutionResult(True, None, {"status": "switched", "property": prop, "value": actual, "matched_outputs": matched})
+    if node_type == "range":
+        prop = str(config_value(config, "property", "payload"))
+        out_prop = str(config_value(config, "output_property", prop))
+        try:
+            value = float(nested_value(message, prop))
+            in_min = float(config_value(config, "input_min", 0))
+            in_max = float(config_value(config, "input_max", 100))
+            out_min = float(config_value(config, "output_min", 0))
+            out_max = float(config_value(config, "output_max", 1))
+        except (TypeError, ValueError):
+            return NodeExecutionResult(False, None, None, "Range node requires numeric input and bounds")
+        scaled = out_min if in_max == in_min else out_min + ((value - in_min) * (out_max - out_min) / (in_max - in_min))
+        if config.get("clamp", True):
+            low, high = sorted((out_min, out_max))
+            scaled = max(low, min(high, scaled))
+        set_nested_value(message, out_prop, scaled)
+        return NodeExecutionResult(True, None, {"status": "ranged", "message": message, "value": scaled})
+    if node_type == "template":
+        template = str(config.get("template") or "")
+        try:
+            rendered = template.format(**message)
+        except Exception:
+            rendered = template
+        set_nested_value(message, str(config_value(config, "output_property", "payload")), rendered)
+        return NodeExecutionResult(True, None, {"status": "templated", "message": message, "value": rendered})
+    if node_type == "delay":
+        delay_ms = max(0, min(int(config_value(config, "delay_ms", 1000)), 10000))
+        await asyncio.sleep(delay_ms / 1000)
+        return NodeExecutionResult(True, None, {"status": "delayed", "delay_ms": delay_ms, "message": message})
+    if node_type == "trigger":
+        reset = config.get("reset")
+        if reset not in (None, "") and str(message.get("payload")) == str(reset):
+            return NodeExecutionResult(True, None, {"status": "reset", "message": message})
+        duration_ms = max(0, min(int(config_value(config, "duration_ms", 0)), 10000))
+        op1_type = config.get("op1type") or config.get("payload_type") or config.get("trigger_type") or "str"
+        op1 = config.get("op1") if "op1" in config else config.get("payload", config.get("trigger"))
+        op2_type = config.get("op2type") or config.get("second_payload_type") or config.get("then_payload_type") or "str"
+        op2 = config.get("op2") if "op2" in config else config.get("second_payload", config.get("then_payload"))
+        first_message = dict(message)
+        first_message["payload"] = coerce_config_value(op1, _node_red_value_type(op1_type))
+        then_message = dict(message)
+        then_message["payload"] = coerce_config_value(op2, _node_red_value_type(op2_type))
+        downstream_message = then_message if op2 not in (None, "") else first_message
+        if duration_ms:
+            await asyncio.sleep(duration_ms / 1000)
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "triggered",
+                "duration_ms": duration_ms,
+                "message": downstream_message,
+                "initial_message": first_message,
+                "then_message": then_message,
+                "messages": [
+                    {"payload": first_message.get("payload"), "delay_ms": 0, "payload_type": op1_type},
+                    {"payload": then_message.get("payload"), "delay_ms": duration_ms, "payload_type": op2_type},
+                ],
+                "payload_type": op1_type,
+                "then_payload_type": op2_type,
+                "extend_delay": bool(config.get("extend")),
+            },
+        )
+    if node_type in {"filter", "rbe"}:
+        prop = str(config_value(config, "property", "payload"))
+        value = nested_value(message, prop)
+        start = config.get("start")
+        previous = config.get("previous", start)
+        mode = str(config_value(config, "mode", "block-unless-value-changes")).lower()
+        gap = float(config_value(config, "gap", 0) or 0)
+        passed = True
+        if mode == "block-unless-value-changes":
+            passed = value != previous
+        elif mode == "block-unless-value-changes-ignore-initial":
+            passed = previous not in (None, "") and value != previous
+        elif mode == "block-if-value-changes":
+            passed = value == previous
+        elif mode in {"narrowband", "deadband"}:
+            try:
+                delta = abs(float(value) - float(previous))
+            except (TypeError, ValueError):
+                delta = 0 if value == previous else gap + 1
+            passed = delta <= gap if mode == "narrowband" else delta > gap
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "passed" if passed else "filtered",
+                "passed": passed,
+                "property": prop,
+                "value": value,
+                "previous": previous,
+                "message": message if passed else None,
+            },
+        )
+    if node_type == "function":
+        code = str(config.get("code") or "return payload").strip()
+        if code.startswith("return "):
+            expression = code.removeprefix("return ").strip()
+            value = nested_value(message, expression) if expression not in {"payload", "message"} else message.get(expression) if expression == "payload" else message
+        else:
+            value = message.get("payload")
+        set_nested_value(message, str(config_value(config, "output_property", "payload")), value)
+        return NodeExecutionResult(True, None, {"status": "functioned", "message": message, "value": value})
+    if node_type == "exec":
+        command = str(config.get("command") or "").strip()
+        if not command:
+            return NodeExecutionResult(False, None, None, "Exec command is required")
+        args = [str(arg) for arg in (config.get("args") or [])]
+        if config.get("append_payload"):
+            args.append(payload_message(payload, config))
+        timeout_seconds = max(1, min(int(config_value(config, "timeout_seconds", 20)), 30))
+        cwd = str(config.get("cwd") or "").strip() or None
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                command,
+                *args,
+                cwd=cwd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout_seconds)
+        except Exception as exc:
+            return NodeExecutionResult(False, None, None, str(exc))
+        body = {
+            "status": "executed" if proc.returncode == 0 else "failed",
+            "return_code": proc.returncode,
+            "stdout": stdout.decode("utf-8", errors="replace"),
+            "stderr": stderr.decode("utf-8", errors="replace"),
+        }
+        return NodeExecutionResult(proc.returncode == 0, None, body, None if proc.returncode == 0 else body["stderr"])
+    return NodeExecutionResult(True, None, {"status": "queued", "message": message})

services/process_definitions/node_services/messaging.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Any
+
+from services.process_definitions.node_services.models import NodeExecutionResult, config_value, render_template
+
+
+async def execute_messaging_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    recipient = str(config_value(config, "to", ""))
+    if not recipient:
+        return NodeExecutionResult(False, None, None, f"{node_type} recipient is required")
+    if node_type == "gmail":
+        body_template = str(config.get("body_template") or "")
+        body = render_template(body_template, payload) if body_template else str(payload.get("body") or payload.get("payload") or "")
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "queued",
+                "provider": config_value(config, "provider", "gmail"),
+                "to": recipient,
+                "cc": config.get("cc") or "",
+                "subject": config.get("subject") or payload.get("subject") or "",
+                "body": body,
+            },
+        )
+    if node_type == "whatsapp":
+        message_template = str(config.get("message_template") or "")
+        message = render_template(message_template, payload) if message_template else str(payload.get("message") or payload.get("payload") or "")
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "queued",
+                "provider": config_value(config, "provider", "whatsapp"),
+                "to": recipient,
+                "message": message,
+            },
+        )
+    return NodeExecutionResult(True, None, {"status": "queued"})

services/process_definitions/node_services/models.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from html.parser import HTMLParser
+import json
+from typing import Any
+import xml.etree.ElementTree as ET
+
+
+@dataclass
+class NodeExecutionResult:
+    ok: bool
+    status_code: int | None
+    response_body: Any
+    error: str | None = None
+
+
+def config_value(config: dict, key: str, default=None):
+    value = config.get(key)
+    return default if value is None or value == "" else value
+
+
+def render_template(template: str, payload: dict[str, Any]) -> str:
+    if not template:
+        return ""
+    try:
+        return template.format(**payload)
+    except Exception:
+        return template
+
+
+def payload_message(payload: dict[str, Any], config: dict, template_key: str = "message_template") -> str:
+    template = config.get(template_key)
+    if isinstance(template, str) and template.strip():
+        try:
+            return template.format(**payload)
+        except Exception:
+            return template
+    if "message" in payload:
+        return str(payload["message"])
+    if "payload" in payload:
+        value = payload["payload"]
+        return value if isinstance(value, str) else json.dumps(value)
+    return json.dumps(payload)
+
+
+def nested_value(value: Any, path: str):
+    current = value
+    for part in path.split("."):
+        if not part:
+            continue
+        if isinstance(current, dict):
+            current = current.get(part)
+        else:
+            return None
+    return current
+
+
+def set_nested_value(value: dict[str, Any], path: str, new_value: Any) -> dict[str, Any]:
+    if not path:
+        return value
+    parts = [part for part in path.split(".") if part]
+    current = value
+    for part in parts[:-1]:
+        child = current.get(part)
+        if not isinstance(child, dict):
+            child = {}
+            current[part] = child
+        current = child
+    if parts:
+        current[parts[-1]] = new_value
+    return value
+
+
+def delete_nested_value(value: dict[str, Any], path: str) -> dict[str, Any]:
+    parts = [part for part in path.split(".") if part]
+    current = value
+    for part in parts[:-1]:
+        child = current.get(part)
+        if not isinstance(child, dict):
+            return value
+        current = child
+    if parts:
+        current.pop(parts[-1], None)
+    return value
+
+
+def coerce_config_value(value: Any, value_type: str | None) -> Any:
+    value_type = (value_type or "json").lower()
+    if value_type == "string":
+        return "" if value is None else str(value)
+    if value_type == "number":
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return 0
+    if value_type == "boolean":
+        if isinstance(value, bool):
+            return value
+        return str(value).strip().lower() in {"true", "1", "yes", "y", "on"}
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except Exception:
+            return value
+    return value
+
+
+def rule_matches(actual: Any, rule: dict) -> bool:
+    operation = str(rule.get("operation") or rule.get("op") or "eq").lower()
+    expected = rule.get("value")
+    if operation in {"exists", "present"}:
+        return actual is not None
+    if operation in {"missing", "not_exists"}:
+        return actual is None
+    if operation in {"eq", "equals", "=="}:
+        return actual == expected
+    if operation in {"neq", "not_equals", "!="}:
+        return actual != expected
+    if operation == "contains":
+        return str(expected) in str(actual)
+    try:
+        actual_num = float(actual)
+        expected_num = float(expected)
+    except (TypeError, ValueError):
+        return False
+    if operation in {"gt", ">"}:
+        return actual_num > expected_num
+    if operation in {"gte", ">="}:
+        return actual_num >= expected_num
+    if operation in {"lt", "<"}:
+        return actual_num < expected_num
+    if operation in {"lte", "<="}:
+        return actual_num <= expected_num
+    return False
+
+
+class SimpleHTMLExtractor(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.text: list[str] = []
+        self.links: list[str] = []
+
+    def handle_data(self, data: str) -> None:
+        stripped = data.strip()
+        if stripped:
+            self.text.append(stripped)
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag.lower() != "a":
+            return
+        for key, value in attrs:
+            if key.lower() == "href" and value:
+                self.links.append(value)
+
+
+def xml_to_dict(element: ET.Element) -> dict:
+    children = list(element)
+    attrs = {f"@{key}": value for key, value in element.attrib.items()}
+    if not children:
+        text = (element.text or "").strip()
+        return {element.tag: {**attrs, "#text": text} if attrs else text}
+    body: dict[str, Any] = dict(attrs)
+    for child in children:
+        child_dict = xml_to_dict(child)
+        for key, value in child_dict.items():
+            if key in body:
+                if not isinstance(body[key], list):
+                    body[key] = [body[key]]
+                body[key].append(value)
+            else:
+                body[key] = value
+    return {element.tag: body}
+
+
+def dict_to_xml(name: str, value: Any) -> ET.Element:
+    element = ET.Element(str(name))
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if str(key).startswith("@"):
+                element.set(str(key)[1:], str(item))
+            elif key == "#text":
+                element.text = str(item)
+            elif isinstance(item, list):
+                for child in item:
+                    element.append(dict_to_xml(str(key), child))
+            else:
+                element.append(dict_to_xml(str(key), item))
+    else:
+        element.text = "" if value is None else str(value)
+    return element
+
+
+def simple_yaml_parse(text: str) -> dict:
+    parsed: dict[str, Any] = {}
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or ":" not in stripped:
+            continue
+        key, value = stripped.split(":", 1)
+        parsed[key.strip()] = coerce_config_value(value.strip(), "json")
+    return parsed
+
+
+def simple_yaml_dump(value: Any) -> str:
+    if isinstance(value, dict):
+        return "\n".join(f"{key}: {json.dumps(item) if isinstance(item, (dict, list)) else item}" for key, item in value.items())
+    return json.dumps(value)
+
+
+def listener_registration_response(node_type: str | None, config: dict) -> dict:
+    return {
+        "status": "registered",
+        "node_type": node_type,
+        "config": {
+            key: value
+            for key, value in config.items()
+            if key not in {"password", "client_secret"}
+        },
+        "message": "Inbound network nodes are registered as canvas node listeners; external listeners should post events to this node's incoming webhook endpoint.",
+    }

services/process_definitions/node_services/network.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from services.process_definitions.models.process_definition import ProcessDefinitionCanvasBackendCall
+from services.process_definitions.node_services.models import (
+    NodeExecutionResult,
+    config_value,
+    listener_registration_response,
+    payload_message,
+    render_template,
+)
+
+
+async def execute_http_node(
+    node_type: str | None,
+    backend: ProcessDefinitionCanvasBackendCall | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    if node_type == "http in":
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "registered",
+                "method": config_value(config, "method", "POST"),
+                "path": config.get("path"),
+                "message": "HTTP input nodes are registered as canvas node listeners; callers should post to this node's incoming webhook endpoint.",
+            },
+        )
+    if node_type == "http response":
+        status_code = int(config_value(config, "status_code", 200))
+        headers = config.get("headers") if isinstance(config.get("headers"), dict) else {}
+        body_template = str(config.get("body_template") or "")
+        body = render_template(body_template, payload) if body_template else payload
+        return NodeExecutionResult(
+            True,
+            status_code,
+            {
+                "status": "response",
+                "status_code": status_code,
+                "headers": headers,
+                "body": body,
+            },
+        )
+    if node_type != "http request":
+        return NodeExecutionResult(True, None, {"status": "queued"})
+    url = (backend.url if backend else None) or config.get("url")
+    if not url:
+        return NodeExecutionResult(False, None, None, "HTTP request URL is required")
+    method = ((backend.method if backend else None) or config.get("method") or "GET").upper()
+    headers = dict((backend.headers if backend else None) or {})
+    query_params = config.get("query") if isinstance(config.get("query"), dict) else None
+    body_template = str(config.get("body_template") or "")
+    body = render_template(body_template, payload) if body_template else payload
+    timeout_seconds = config.get("timeout_seconds") if isinstance(config.get("timeout_seconds"), (int, float)) else 20.0
+    try:
+        async with httpx.AsyncClient(timeout=float(timeout_seconds)) as client:
+            response = await client.request(
+                method,
+                url,
+                json=None if method == "GET" else body,
+                headers=headers,
+                params=query_params,
+            )
+        try:
+            response_body = response.json()
+        except Exception:
+            response_body = response.text
+        return NodeExecutionResult(response.is_success, response.status_code, response_body, None if response.is_success else response.text)
+    except httpx.HTTPError as exc:
+        return NodeExecutionResult(False, None, None, str(exc))
+
+
+async def execute_mqtt_node(node_type: str | None, config: dict, payload: dict[str, Any]) -> NodeExecutionResult:
+    if node_type == "mqtt in":
+        return NodeExecutionResult(True, None, listener_registration_response(node_type, config))
+    if node_type != "mqtt out":
+        return NodeExecutionResult(True, None, {"status": "queued"})
+    try:
+        import paho.mqtt.client as mqtt
+    except Exception:
+        return NodeExecutionResult(False, None, None, "paho-mqtt is not installed; cannot publish MQTT message")
+    broker = urlparse(str(config_value(config, "broker_url", "mqtt://localhost:1883")))
+    host = str(config_value(config, "host", broker.hostname or "localhost"))
+    port = int(config_value(config, "port", broker.port or 1883))
+    topic = str(config_value(config, "topic", ""))
+    if not topic:
+        return NodeExecutionResult(False, None, None, "MQTT topic is required")
+    client_id = str(config_value(config, "client_id", ""))
+    username = config_value(config, "username")
+    password = config_value(config, "password")
+    qos = int(config_value(config, "qos", 0))
+    retain = bool(config.get("retain") or False)
+    message = payload_message(payload, config, "payload_template")
+    client = mqtt.Client(client_id=client_id or "")
+    if username:
+        client.username_pw_set(str(username), str(password or ""))
+    client.connect(host, port, keepalive=30)
+    result = client.publish(topic, message, qos=qos, retain=retain)
+    result.wait_for_publish(timeout=float(config_value(config, "timeout_seconds", 20)))
+    client.disconnect()
+    ok = result.rc == mqtt.MQTT_ERR_SUCCESS
+    return NodeExecutionResult(ok, None, {"topic": topic, "published": ok, "rc": result.rc}, None if ok else f"MQTT publish failed rc={result.rc}")
+
+
+async def execute_websocket_node(node_type: str | None, config: dict, payload: dict[str, Any]) -> NodeExecutionResult:
+    if node_type == "websocket in":
+        return NodeExecutionResult(True, None, listener_registration_response(node_type, config))
+    if node_type != "websocket out":
+        return NodeExecutionResult(True, None, {"status": "queued"})
+    try:
+        import websockets
+    except Exception:
+        return NodeExecutionResult(False, None, None, "websockets is not installed; cannot send WebSocket message")
+    url = str(config_value(config, "url", ""))
+    if not url:
+        return NodeExecutionResult(False, None, None, "WebSocket URL is required")
+    headers = config.get("headers") if isinstance(config.get("headers"), dict) else {}
+    if config.get("client_key"):
+        headers = {**headers, "x-client-key": str(config["client_key"])}
+    if config.get("client_secret"):
+        headers = {**headers, "x-client-secret": str(config["client_secret"])}
+    message = payload_message(payload, config)
+    timeout_seconds = float(config_value(config, "timeout_seconds", 20))
+    async with asyncio.timeout(timeout_seconds):
+        async with websockets.connect(url, extra_headers=headers) as websocket:
+            await websocket.send(message)
+    return NodeExecutionResult(True, None, {"url": url, "sent": True})
+
+
+async def execute_tcp_udp_node(node_type: str | None, config: dict, payload: dict[str, Any]) -> NodeExecutionResult:
+    if node_type in {"tcp in", "udp in"}:
+        return NodeExecutionResult(True, None, listener_registration_response(node_type, config))
+    host = str(config_value(config, "host", "localhost"))
+    port = config_value(config, "port")
+    if port is None:
+        return NodeExecutionResult(False, None, None, f"{node_type} port is required")
+    port = int(port)
+    encoding = str(config_value(config, "encoding", "utf-8"))
+    message = payload_message(payload, config).encode(encoding)
+    timeout_seconds = float(config_value(config, "timeout_seconds", 20))
+    if node_type == "tcp out":
+        reader, writer = await asyncio.wait_for(asyncio.open_connection(host, port), timeout=timeout_seconds)
+        writer.write(message)
+        await writer.drain()
+        writer.close()
+        await writer.wait_closed()
+        return NodeExecutionResult(True, None, {"host": host, "port": port, "bytes_sent": len(message)})
+    if node_type == "udp out":
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.settimeout(timeout_seconds)
+            sent = sock.sendto(message, (host, port))
+        return NodeExecutionResult(True, None, {"host": host, "port": port, "bytes_sent": sent})
+    return NodeExecutionResult(True, None, {"status": "queued"})