monkeybrain-runtime 1.0.0__py3-none-any.whl

services/process_definitions/node_services/parsers.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import csv
+import io
+import json
+from typing import Any
+import xml.etree.ElementTree as ET
+
+from services.process_definitions.node_services.models import (
+    NodeExecutionResult,
+    SimpleHTMLExtractor,
+    config_value,
+    dict_to_xml,
+    nested_value,
+    set_nested_value,
+    simple_yaml_dump,
+    simple_yaml_parse,
+    xml_to_dict,
+)
+
+
+async def execute_parser_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    message = dict(payload)
+    prop = str(config_value(config, "property", "payload"))
+    mode = str(config_value(config, "mode", "parse")).lower()
+    value = nested_value(message, prop)
+    try:
+        if node_type == "json":
+            result = json.loads(value) if mode == "parse" and isinstance(value, str) else json.dumps(value)
+        elif node_type == "csv":
+            delimiter = str(config_value(config, "delimiter", ","))[:1] or ","
+            if mode == "parse":
+                text = "" if value is None else str(value)
+                reader = csv.DictReader(io.StringIO(text), delimiter=delimiter) if config.get("has_header", True) else csv.reader(io.StringIO(text), delimiter=delimiter)
+                result = list(reader)
+            else:
+                rows = value if isinstance(value, list) else [value]
+                output = io.StringIO()
+                if rows and all(isinstance(row, dict) for row in rows):
+                    fieldnames = list({key for row in rows for key in row.keys()})
+                    writer = csv.DictWriter(output, fieldnames=fieldnames, delimiter=delimiter)
+                    if config.get("has_header", True):
+                        writer.writeheader()
+                    writer.writerows(rows)
+                else:
+                    writer = csv.writer(output, delimiter=delimiter)
+                    for row in rows:
+                        writer.writerow(row if isinstance(row, list) else [row])
+                result = output.getvalue()
+        elif node_type == "html":
+            if mode == "parse":
+                parser = SimpleHTMLExtractor()
+                parser.feed("" if value is None else str(value))
+                extract = str(config_value(config, "extract", "text"))
+                result = parser.links if extract == "links" else value if extract == "raw" else " ".join(parser.text)
+            else:
+                result = "" if value is None else str(value)
+        elif node_type == "xml":
+            if mode == "parse":
+                root = ET.fromstring("" if value is None else str(value))
+                result = xml_to_dict(root)
+            else:
+                if isinstance(value, dict) and len(value) == 1:
+                    root_name, root_value = next(iter(value.items()))
+                    element = dict_to_xml(root_name, root_value)
+                else:
+                    element = dict_to_xml("root", value)
+                result = ET.tostring(element, encoding="unicode")
+        elif node_type == "yaml":
+            try:
+                import yaml
+            except Exception:
+                yaml = None
+            if mode == "parse":
+                result = yaml.safe_load(value) if yaml else simple_yaml_parse("" if value is None else str(value))
+            else:
+                result = yaml.safe_dump(value, sort_keys=False) if yaml else simple_yaml_dump(value)
+        else:
+            result = value
+    except Exception as exc:
+        return NodeExecutionResult(False, None, None, str(exc))
+    set_nested_value(message, prop, result)
+    return NodeExecutionResult(True, None, {"status": f"{node_type}-{mode}", "message": message, "value": result})

services/process_definitions/node_services/sequence.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Any
+
+from services.process_definitions.node_services.models import (
+    NodeExecutionResult,
+    config_value,
+    nested_value,
+    set_nested_value,
+)
+
+
+async def execute_sequence_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    message = dict(payload)
+    prop = str(config_value(config, "property", "payload"))
+    value = nested_value(message, prop)
+    if node_type == "split":
+        if isinstance(value, str):
+            separator = str(config.get("separator") or "")
+            items = list(value) if separator == "" else value.split(separator)
+        elif isinstance(value, dict):
+            items = [{"key": key, "value": item} for key, item in value.items()]
+        elif isinstance(value, list):
+            items = value
+        else:
+            items = [] if value is None else [value]
+        messages = []
+        for index, item in enumerate(items):
+            part = dict(message)
+            set_nested_value(part, prop, item)
+            if config.get("include_parts", True):
+                part["parts"] = {"id": payload.get("_msgid") or payload.get("id"), "index": index, "count": len(items)}
+            messages.append(part)
+        return NodeExecutionResult(True, None, {"status": "split", "messages": messages, "count": len(messages)})
+    if node_type == "join":
+        messages = payload.get("messages") if isinstance(payload.get("messages"), list) else payload.get("payload")
+        if not isinstance(messages, list):
+            messages = [payload]
+        values = []
+        for item in messages:
+            values.append(nested_value(item, prop) if isinstance(item, dict) else item)
+        mode = str(config_value(config, "mode", "array"))
+        if mode == "string":
+            joined = str(config.get("separator") or "").join(str(item) for item in values)
+        elif mode == "object":
+            joined = {}
+            key_prop = str(config_value(config, "key_property", "topic"))
+            for index, item in enumerate(messages):
+                key = nested_value(item, key_prop) if isinstance(item, dict) else index
+                joined[str(key)] = values[index]
+        else:
+            joined = values
+        set_nested_value(message, prop, joined)
+        return NodeExecutionResult(True, None, {"status": "joined", "message": message, "count": len(values)})
+    if node_type == "sort":
+        if not isinstance(value, list):
+            return NodeExecutionResult(False, None, None, "Sort node requires a list at the configured property")
+        key_path = str(config.get("key") or "")
+        numeric = bool(config.get("numeric") or False)
+        reverse = str(config_value(config, "direction", "ascending")).lower() == "descending"
+
+        def sort_key(item):
+            raw = nested_value(item, key_path) if key_path and isinstance(item, dict) else item
+            if numeric:
+                try:
+                    return float(raw)
+                except (TypeError, ValueError):
+                    return 0
+            return "" if raw is None else str(raw)
+
+        sorted_items = sorted(value, key=sort_key, reverse=reverse)
+        set_nested_value(message, prop, sorted_items)
+        return NodeExecutionResult(True, None, {"status": "sorted", "message": message, "count": len(sorted_items)})
+    if node_type == "batch":
+        if not isinstance(value, list):
+            return NodeExecutionResult(False, None, None, "Batch node requires a list at the configured property")
+        size = max(1, int(config_value(config, "size", 10)))
+        overlap = max(0, min(int(config_value(config, "overlap", 0)), size - 1))
+        step = max(1, size - overlap)
+        messages = []
+        for index, start in enumerate(range(0, len(value), step)):
+            batch = value[start:start + size]
+            if not batch:
+                continue
+            part = dict(message)
+            set_nested_value(part, prop, batch)
+            if config.get("include_parts", True):
+                part["parts"] = {"index": index, "start": start, "size": len(batch)}
+            messages.append(part)
+        return NodeExecutionResult(True, None, {"status": "batched", "messages": messages, "count": len(messages)})
+    return NodeExecutionResult(True, None, {"status": "queued", "message": message})

services/process_definitions/node_services/storage.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from services.process_definitions.node_services.models import NodeExecutionResult, config_value
+
+
+async def execute_storage_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    path_value = str(config_value(config, "path", ""))
+    if not path_value:
+        return NodeExecutionResult(False, None, None, f"{node_type} path is required")
+    path = Path(path_value).expanduser()
+    encoding = str(config_value(config, "encoding", "utf-8"))
+    if node_type == "watch":
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "registered",
+                "path": str(path),
+                "recursive": bool(config.get("recursive") or False),
+                "events": config.get("events") or [],
+            },
+        )
+    if node_type == "file in":
+        if not path.exists():
+            return NodeExecutionResult(False, None, None, f"File '{path}' not found")
+        mode = str(config_value(config, "mode", "text"))
+        if mode == "bytes":
+            value: Any = path.read_bytes().hex()
+        else:
+            text = path.read_text(encoding=encoding)
+            value = json.loads(text) if mode == "json" else text
+        return NodeExecutionResult(True, None, {"status": "read", "path": str(path), "payload": value})
+    if node_type == "file":
+        if config.get("create_dirs", True):
+            path.parent.mkdir(parents=True, exist_ok=True)
+        value = payload.get("payload", payload)
+        text = value if isinstance(value, str) else json.dumps(value)
+        mode = "a" if config.get("append") else "w"
+        with path.open(mode, encoding=encoding) as handle:
+            handle.write(text)
+        return NodeExecutionResult(True, None, {"status": "written", "path": str(path), "bytes": len(text.encode(encoding))})
+    return NodeExecutionResult(True, None, {"status": "queued"})

services/process_definitions/node_services/webhooks.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from services.common.n8n_auth import n8n_webhook_auth_headers
+from services.process_definitions.node_services.models import NodeExecutionResult, config_value
+
+
+async def execute_webhook_node(
+    node_type: str | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    provider = str(config_value(config, "provider", node_type or "webhook"))
+    if node_type in {"incoming webhook", "n8n incoming", "openclaw incoming"}:
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "registered",
+                "provider": provider,
+                "path": config.get("path"),
+                "message": "Incoming webhook nodes are registered as canvas node listeners; post to this node's incoming webhook endpoint.",
+            },
+        )
+    url = str(config_value(config, "url", ""))
+    if not url:
+        return NodeExecutionResult(False, None, None, f"{node_type} URL is required")
+    method = str(config_value(config, "method", "POST")).upper()
+    headers = config.get("headers") if isinstance(config.get("headers"), dict) else {}
+    if str(provider).lower() == "n8n":
+        headers = n8n_webhook_auth_headers(headers)
+    if config.get("secret"):
+        headers = {**headers, "x-canvas-webhook-secret": str(config["secret"])}
+    timeout_seconds = float(config_value(config, "timeout_seconds", 20))
+    try:
+        async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+            response = await client.request(method, url, json=payload, headers=headers)
+        try:
+            body = response.json()
+        except Exception:
+            body = response.text
+        return NodeExecutionResult(
+            response.is_success,
+            response.status_code,
+            {"status": "sent" if response.is_success else "failed", "provider": provider, "body": body},
+            None if response.is_success else response.text,
+        )
+    except httpx.HTTPError as exc:
+        return NodeExecutionResult(False, None, None, str(exc))

services/process_definitions/routers/__init__.py

@@ -0,0 +1,10 @@
+"""process definition service routers package."""
+
+__all__ = [
+    "process_definition",
+    "process_constraints",
+    "process_corrections",
+    "process_post_checks",
+    "process_pre_checks",
+    "process_steps",
+]

services/process_definitions/routers/cpp_cqa_registry.py

@@ -0,0 +1,86 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.process_definitions.helpers import cpp_cqa_registry as crud
+from services.process_definitions.models.cpp_cqa_registry import (
+    CppCqaRegistryCreate,
+    CppCqaRegistryResponse,
+    CppCqaRegistryUpdate,
+    PaginatedCppCqaRegistryResponse,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedCppCqaRegistryResponse)
+async def list_cpp_cqa_registry(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    registry_type: str | None = Query(None),
+    process_definition_id: str | None = Query(None),
+    process_step_id: str | None = Query(None),
+    stage_id: str | None = Query(None),
+    status_filter: str | None = Query(None, alias="status"),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    records, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        registry_type=registry_type,
+        process_definition_id=process_definition_id,
+        process_step_id=process_step_id,
+        stage_id=stage_id,
+        status=status_filter,
+    )
+    return PaginatedCppCqaRegistryResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/{registry_id}", response_model=CppCqaRegistryResponse)
+async def get_cpp_cqa_registry_entry(
+    registry_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    record = await crud.get_by_id(db, registry_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"CPP/CQA registry entry '{registry_id}' not found")
+    return record
+
+
+@router.post("/", response_model=CppCqaRegistryResponse, status_code=status.HTTP_201_CREATED)
+async def create_cpp_cqa_registry_entry(
+    data: CppCqaRegistryCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-process-definitions")),
+):
+    if await crud.get_by_id(db, data.registry_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"CPP/CQA registry entry '{data.registry_id}' already exists")
+    return await crud.create(db, data)
+
+
+@router.patch("/{registry_id}", response_model=CppCqaRegistryResponse)
+async def update_cpp_cqa_registry_entry(
+    registry_id: str,
+    data: CppCqaRegistryUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-process-definitions")),
+):
+    updated = await crud.update(db, registry_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"CPP/CQA registry entry '{registry_id}' not found")
+    return updated
+
+
+@router.delete("/{registry_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_cpp_cqa_registry_entry(
+    registry_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-process-definitions")),
+):
+    if not await crud.delete(db, registry_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"CPP/CQA registry entry '{registry_id}' not found")

services/process_definitions/routers/mbmr_templates.py

@@ -0,0 +1,84 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.process_definitions.helpers import mbmr_templates as crud
+from services.process_definitions.models.mbmr_templates import (
+    MbmrTemplateCreate,
+    MbmrTemplateResponse,
+    MbmrTemplateUpdate,
+    PaginatedMbmrTemplateResponse,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedMbmrTemplateResponse)
+async def list_mbmr_templates(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    process_definition_id: str | None = Query(None),
+    bom_id: str | None = Query(None),
+    status_filter: str | None = Query(None, alias="status"),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    records, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        process_definition_id=process_definition_id,
+        bom_id=bom_id,
+        status=status_filter,
+    )
+    return PaginatedMbmrTemplateResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/{mbmr_template_id}", response_model=MbmrTemplateResponse)
+async def get_mbmr_template(
+    mbmr_template_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    record = await crud.get_by_id(db, mbmr_template_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"MBMR template '{mbmr_template_id}' not found")
+    return record
+
+
+@router.post("/", response_model=MbmrTemplateResponse, status_code=status.HTTP_201_CREATED)
+async def create_mbmr_template(
+    data: MbmrTemplateCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    current_user: dict = Depends(require_permission("perm-create-process-definitions")),
+):
+    if await crud.get_by_id(db, data.mbmr_template_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"MBMR template '{data.mbmr_template_id}' already exists")
+    if data.created_by is None:
+        data.created_by = current_user.get("sub")
+    return await crud.create(db, data)
+
+
+@router.patch("/{mbmr_template_id}", response_model=MbmrTemplateResponse)
+async def update_mbmr_template(
+    mbmr_template_id: str,
+    data: MbmrTemplateUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-process-definitions")),
+):
+    updated = await crud.update(db, mbmr_template_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"MBMR template '{mbmr_template_id}' not found")
+    return updated
+
+
+@router.delete("/{mbmr_template_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_mbmr_template(
+    mbmr_template_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-process-definitions")),
+):
+    if not await crud.delete(db, mbmr_template_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"MBMR template '{mbmr_template_id}' not found")

services/process_definitions/routers/packing_instructions.py

@@ -0,0 +1,84 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.process_definitions.helpers import packing_instructions as crud
+from services.process_definitions.models.packing_instructions import (
+    PackingInstructionCreate,
+    PackingInstructionResponse,
+    PackingInstructionUpdate,
+    PaginatedPackingInstructionResponse,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedPackingInstructionResponse)
+async def list_packing_instructions(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    process_definition_id: str | None = Query(None),
+    bpr_document_id: str | None = Query(None),
+    status_filter: str | None = Query(None, alias="status"),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    records, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        process_definition_id=process_definition_id,
+        bpr_document_id=bpr_document_id,
+        status=status_filter,
+    )
+    return PaginatedPackingInstructionResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/{packing_instruction_id}", response_model=PackingInstructionResponse)
+async def get_packing_instruction(
+    packing_instruction_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-process-definitions")),
+):
+    record = await crud.get_by_id(db, packing_instruction_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Packing instruction '{packing_instruction_id}' not found")
+    return record
+
+
+@router.post("/", response_model=PackingInstructionResponse, status_code=status.HTTP_201_CREATED)
+async def create_packing_instruction(
+    data: PackingInstructionCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    current_user: dict = Depends(require_permission("perm-create-process-definitions")),
+):
+    if await crud.get_by_id(db, data.packing_instruction_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Packing instruction '{data.packing_instruction_id}' already exists")
+    if data.created_by is None:
+        data.created_by = current_user.get("sub")
+    return await crud.create(db, data)
+
+
+@router.patch("/{packing_instruction_id}", response_model=PackingInstructionResponse)
+async def update_packing_instruction(
+    packing_instruction_id: str,
+    data: PackingInstructionUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-process-definitions")),
+):
+    updated = await crud.update(db, packing_instruction_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Packing instruction '{packing_instruction_id}' not found")
+    return updated
+
+
+@router.delete("/{packing_instruction_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_packing_instruction(
+    packing_instruction_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-process-definitions")),
+):
+    if not await crud.delete(db, packing_instruction_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Packing instruction '{packing_instruction_id}' not found")