monkeybrain-runtime 1.0.0__py3-none-any.whl

services/process_definitions/models/process_definition_common.py

@@ -0,0 +1,48 @@
+"""
+process_definition/enums.py
+-----------------
+Shared enumerations used across all process_definition models.
+"""
+
+from enum import Enum
+
+
+class Severity(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class Status(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    BLOCKED = "blocked"
+
+
+class ConditionOperator(str, Enum):
+    EQUALS = "equals"
+    NOT_EQUALS = "not_equals"
+    GREATER_THAN = "greater_than"
+    LESS_THAN = "less_than"
+    CONTAINS = "contains"
+    EXISTS = "exists"
+    NOT_EXISTS = "not_exists"
+
+
+class ConstraintType(str, Enum):
+    RESOURCE = "resource"            # e.g. "must not access DB during migration"
+    TEMPORAL = "temporal"            # e.g. "must not run between 09:00–17:00"
+    ENVIRONMENTAL = "environmental"  # e.g. "must not run in production"
+    OPERATIONAL = "operational"      # e.g. "must not restart service X"
+    SECURITY = "security"            # e.g. "must not expose credentials"
+    CONCURRENCY = "concurrency"      # e.g. "only one instance may run at a time"
+
+
+class ActionType(str, Enum):
+    MANUAL = "manual"        # Human must perform
+    AUTOMATED = "automated"  # System can execute automatically
+    HYBRID = "hybrid"        # Combination of both

services/process_definitions/models/process_node_catalog.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ProcessNodeCatalogItem(BaseModel):
+    type: str = Field(..., min_length=1)
+    label: str = Field(..., min_length=1)
+    category: str = Field(..., min_length=1)
+    key: str = Field(..., min_length=1)
+    description: Optional[str] = None
+    config_schema: dict[str, Any] = Field(default_factory=dict)
+    defaults: dict[str, Any] = Field(default_factory=dict)
+
+
+class ProcessNodeCatalogCategory(BaseModel):
+    category: str = Field(..., min_length=1)
+    nodes: list[ProcessNodeCatalogItem] = Field(default_factory=list)
+
+
+class ProcessNodeCatalogResponse(BaseModel):
+    categories: list[ProcessNodeCatalogCategory] = Field(default_factory=list)
+    nodes: list[ProcessNodeCatalogItem] = Field(default_factory=list)

services/process_definitions/models/process_post_checks.py

@@ -0,0 +1,171 @@
+"""
+models/process_post_checks.py
+------------------------------
+Post-condition models that verify a process_definition completed successfully.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.process_definitions.models.process_definition_common import ConditionOperator, Severity
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(dt: Optional[datetime]) -> Optional[datetime]:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+# ---------------------------------------------------------------------------
+# PostCheckCondition
+# ---------------------------------------------------------------------------
+
+class PostCheckCondition(BaseModel):
+    id:                             str                = Field(..., min_length=1)
+    name:                           str                = Field(..., min_length=1)
+    description:                    str                = Field(...)
+    operator:                       ConditionOperator  = Field(...)
+    expected_value:                 Optional[str]      = None
+    is_mandatory:                   bool               = True
+    severity:                       Severity           = Field(default=Severity.HIGH)
+    check_command:                  Optional[str]      = None
+    links_to_corrective_action_ids: List[str]          = Field(default_factory=list)
+    created_at:                     datetime           = Field(default_factory=utc_now)
+    updated_at:                     datetime           = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "PostCheckCondition":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class PostCheckConditionCreate(PostCheckCondition):
+    pass
+
+
+class PostCheckConditionUpdate(BaseModel):
+    name:                           Optional[str]               = None
+    description:                    Optional[str]               = None
+    operator:                       Optional[ConditionOperator] = None
+    expected_value:                 Optional[str]               = None
+    is_mandatory:                   Optional[bool]              = None
+    severity:                       Optional[Severity]          = None
+    check_command:                  Optional[str]               = None
+    links_to_corrective_action_ids: Optional[List[str]]         = None
+    updated_at:                     datetime                    = Field(default_factory=utc_now)
+
+
+class PostCheckConditionResponse(PostCheckCondition):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# ProcessPostchecks
+# ---------------------------------------------------------------------------
+
+class ProcessPostchecks(BaseModel):
+    id:               str                       = Field(..., min_length=1)
+    process_definition_id:      str                       = Field(..., min_length=1)
+    description:      Optional[str]             = None
+    conditions:       List[PostCheckCondition]  = Field(default_factory=list)
+    all_must_pass:    bool                      = True
+    timeout_seconds:  Optional[int]             = None
+    created_at:       datetime                  = Field(default_factory=utc_now)
+    updated_at:       datetime                  = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessPostchecks":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessPostchecksCreate(ProcessPostchecks):
+    pass
+
+
+class ProcessPostchecksUpdate(BaseModel):
+    description:      Optional[str]                      = None
+    conditions:       Optional[List[PostCheckCondition]] = None
+    all_must_pass:    Optional[bool]                     = None
+    timeout_seconds:  Optional[int]                      = None
+    updated_at:       datetime                           = Field(default_factory=utc_now)
+
+
+class ProcessPostchecksResponse(ProcessPostchecks):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# ProcessStepPostchecks
+# ---------------------------------------------------------------------------
+
+class ProcessStepPostchecks(BaseModel):
+    id:               str                       = Field(..., min_length=1)
+    process_definition_id:      str                       = Field(..., min_length=1)
+    process_step_id: str                       = Field(..., min_length=1)
+    description:      Optional[str]             = None
+    conditions:       List[PostCheckCondition]  = Field(default_factory=list)
+    all_must_pass:    bool                      = True
+    timeout_seconds:  Optional[int]             = None
+    created_at:       datetime                  = Field(default_factory=utc_now)
+    updated_at:       datetime                  = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessStepPostchecks":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessStepPostchecksCreate(ProcessStepPostchecks):
+    pass
+
+
+class ProcessStepPostchecksUpdate(BaseModel):
+    description:      Optional[str]                      = None
+    conditions:       Optional[List[PostCheckCondition]] = None
+    all_must_pass:    Optional[bool]                     = None
+    timeout_seconds:  Optional[int]                      = None
+    updated_at:       datetime                           = Field(default_factory=utc_now)
+
+
+class ProcessStepPostchecksResponse(ProcessStepPostchecks):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# Paginated responses
+# ---------------------------------------------------------------------------
+
+class PaginatedProcessPostchecksResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[ProcessPostchecksResponse]
+
+
+class PaginatedProcessStepPostchecksResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[ProcessStepPostchecksResponse]

services/process_definitions/models/process_pre_checks.py

@@ -0,0 +1,168 @@
+"""
+models/process_pre_checks.py
+-----------------------------
+Pre-condition models that gate process_definition execution.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.process_definitions.models.process_definition_common import ConditionOperator, Severity
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(dt: Optional[datetime]) -> Optional[datetime]:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+# ---------------------------------------------------------------------------
+# PreCheckCondition
+# ---------------------------------------------------------------------------
+
+class PreCheckCondition(BaseModel):
+    id:                str                = Field(..., min_length=1)
+    name:              str                = Field(..., min_length=1)
+    description:       str                = Field(...)
+    operator:          ConditionOperator  = Field(...)
+    expected_value:    Optional[str]      = None
+    is_mandatory:      bool               = True
+    severity:          Severity           = Field(default=Severity.HIGH)
+    check_command:     Optional[str]      = None
+    remediation_hint:  Optional[str]      = None
+    created_at:        datetime           = Field(default_factory=utc_now)
+    updated_at:        datetime           = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "PreCheckCondition":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class PreCheckConditionCreate(PreCheckCondition):
+    pass
+
+
+class PreCheckConditionUpdate(BaseModel):
+    name:              Optional[str]               = None
+    description:       Optional[str]               = None
+    operator:          Optional[ConditionOperator] = None
+    expected_value:    Optional[str]               = None
+    is_mandatory:      Optional[bool]              = None
+    severity:          Optional[Severity]          = None
+    check_command:     Optional[str]               = None
+    remediation_hint:  Optional[str]               = None
+    updated_at:        datetime                    = Field(default_factory=utc_now)
+
+
+class PreCheckConditionResponse(PreCheckCondition):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# ProcessPrechecks
+# ---------------------------------------------------------------------------
+
+class ProcessPrechecks(BaseModel):
+    id:                           str                      = Field(..., min_length=1)
+    process_definition_id:                  str                      = Field(..., min_length=1)
+    description:                  Optional[str]            = None
+    conditions:                   List[PreCheckCondition]  = Field(default_factory=list)
+    all_must_pass:                bool                     = True
+    timeout_seconds:              Optional[int]            = None
+    created_at:                   datetime                 = Field(default_factory=utc_now)
+    updated_at:                   datetime                 = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessPrechecks":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessPrechecksCreate(ProcessPrechecks):
+    pass
+
+
+class ProcessPrechecksUpdate(BaseModel):
+    description:      Optional[str]                     = None
+    conditions:       Optional[List[PreCheckCondition]] = None
+    all_must_pass:    Optional[bool]                    = None
+    timeout_seconds:  Optional[int]                     = None
+    updated_at:       datetime                          = Field(default_factory=utc_now)
+
+
+class ProcessPrechecksResponse(ProcessPrechecks):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# ProcessStepPrechecks
+# ---------------------------------------------------------------------------
+
+class ProcessStepPrechecks(BaseModel):
+    id:               str                      = Field(..., min_length=1)
+    process_definition_id:      str                      = Field(..., min_length=1)
+    process_step_id: str                      = Field(..., min_length=1)
+    description:      Optional[str]            = None
+    conditions:       List[PreCheckCondition]  = Field(default_factory=list)
+    all_must_pass:    bool                     = True
+    timeout_seconds:  Optional[int]            = None
+    created_at:       datetime                 = Field(default_factory=utc_now)
+    updated_at:       datetime                 = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessStepPrechecks":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessStepPrechecksCreate(ProcessStepPrechecks):
+    pass
+
+
+class ProcessStepPrechecksUpdate(BaseModel):
+    description:      Optional[str]                     = None
+    conditions:       Optional[List[PreCheckCondition]] = None
+    all_must_pass:    Optional[bool]                    = None
+    timeout_seconds:  Optional[int]                     = None
+    updated_at:       datetime                          = Field(default_factory=utc_now)
+
+
+class ProcessStepPrechecksResponse(ProcessStepPrechecks):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedProcessPrechecksResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[ProcessPrechecksResponse]
+
+
+class PaginatedProcessStepPrechecksResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[ProcessStepPrechecksResponse]

services/process_definitions/models/process_steps.py

@@ -0,0 +1,170 @@
+"""
+models/process_steps.py
+------------------------
+Execution step models that define the body of a process_definition.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.process_definitions.models.process_constraints import ProcessStepConstraints
+from services.process_definitions.models.process_corrections import CorrectiveActions
+from services.process_definitions.models.process_post_checks import ProcessStepPostchecks
+from services.process_definitions.models.process_pre_checks import ProcessStepPrechecks
+from services.process_definitions.models.process_definition_common import Status, ActionType
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(dt: Optional[datetime]) -> Optional[datetime]:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+# ---------------------------------------------------------------------------
+# Step sub-models
+# ---------------------------------------------------------------------------
+
+class StepInput(BaseModel):
+    name:        str           = Field(..., min_length=1)
+    value:       Optional[str] = None
+    description: Optional[str] = None
+    is_required: bool          = True
+
+
+class StepInputUpdate(BaseModel):
+    name:        Optional[str]  = None
+    value:       Optional[str]  = None
+    description: Optional[str]  = None
+    is_required: Optional[bool] = None
+
+
+class StepOutput(BaseModel):
+    name:        str           = Field(..., min_length=1)
+    description: Optional[str] = None
+    value:       Optional[str] = None
+
+
+class StepOutputUpdate(BaseModel):
+    name:        Optional[str] = None
+    description: Optional[str] = None
+    value:       Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# ProcessStep
+# ---------------------------------------------------------------------------
+
+class ProcessStep(BaseModel):
+    id:               str                     = Field(..., min_length=1)
+    sequence:         int                     = Field(..., ge=1)
+    name:             str                     = Field(..., min_length=1)
+    description:      str                     = Field(...)
+    action_type:      ActionType              = Field(default=ActionType.MANUAL)
+    command:          Optional[str]           = None
+    inputs:           List[StepInput]         = Field(default_factory=list)
+    outputs:          List[StepOutput]        = Field(default_factory=list)
+    depends_on:       List[str]               = Field(default_factory=list)
+    is_optional:      bool                    = False
+    timeout_seconds:  Optional[int]           = None
+    retry_count:      int                     = Field(default=0, ge=0)
+    status:           Status                  = Field(default=Status.PENDING)
+    prechecks:        ProcessStepPrechecks
+    postchecks:       ProcessStepPostchecks
+    constraints:      ProcessStepConstraints
+    corrective_actions: CorrectiveActions
+    notes:            Optional[str]           = None
+    created_at:       datetime                = Field(default_factory=utc_now)
+    updated_at:       datetime                = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessStep":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessStepCreate(ProcessStep):
+    pass
+
+
+class ProcessStepUpdate(BaseModel):
+    sequence:         Optional[int]                      = Field(None, ge=1)
+    name:             Optional[str]                      = None
+    description:      Optional[str]                      = None
+    action_type:      Optional[ActionType]               = None
+    command:          Optional[str]                      = None
+    inputs:           Optional[List[StepInput]]          = None
+    outputs:          Optional[List[StepOutput]]         = None
+    depends_on:       Optional[List[str]]                = None
+    is_optional:      Optional[bool]                     = None
+    timeout_seconds:  Optional[int]                      = None
+    retry_count:      Optional[int]                      = Field(None, ge=0)
+    status:           Optional[Status]                   = None
+    prechecks:        Optional[ProcessStepPrechecks]    = None
+    postchecks:       Optional[ProcessStepPostchecks]   = None
+    constraints:      Optional[ProcessStepConstraints]  = None
+    corrective_actions: Optional[CorrectiveActions]      = None
+    notes:            Optional[str]                      = None
+    updated_at:       datetime                           = Field(default_factory=utc_now)
+
+
+class ProcessStepResponse(ProcessStep):
+    class Config:
+        from_attributes = True
+
+
+# ---------------------------------------------------------------------------
+# ProcessSteps (collection)
+# ---------------------------------------------------------------------------
+
+class ProcessSteps(BaseModel):
+    id:                       str                    = Field(..., min_length=1)
+    process_definition_id:              str                    = Field(..., min_length=1)
+    description:              Optional[str]          = None
+    steps:                    List[ProcessStep]     = Field(default_factory=list)
+    allow_parallel_execution: bool                   = False
+    rollback_on_failure:      bool                   = False
+    created_at:               datetime               = Field(default_factory=utc_now)
+    updated_at:               datetime               = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "ProcessSteps":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class ProcessStepsCreate(ProcessSteps):
+    pass
+
+
+class ProcessStepsUpdate(BaseModel):
+    description:              Optional[str]               = None
+    steps:                    Optional[List[ProcessStep]] = None
+    allow_parallel_execution: Optional[bool]              = None
+    rollback_on_failure:      Optional[bool]              = None
+    updated_at:               datetime                    = Field(default_factory=utc_now)
+
+
+class ProcessStepsResponse(ProcessSteps):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedProcessStepsResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[ProcessStepsResponse]

services/process_definitions/node_services/__init__.py

@@ -0,0 +1,8 @@
+"""ProcessDefinition canvas node execution services."""
+
+__all__ = [
+    "messaging",
+    "models",
+    "storage",
+    "webhooks",
+]

services/process_definitions/node_services/common.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from services.process_definitions.node_services.models import (
+    NodeExecutionResult,
+    config_value,
+    nested_value,
+)
+
+
+def node_type_from_record(node: dict) -> str | None:
+    metadata = node.get("metadata") if isinstance(node.get("metadata"), dict) else {}
+    return (
+        node.get("node_type")
+        or metadata.get("nodeType")
+        or metadata.get("type")
+    )
+
+
+def inject_payload(config: dict, payload: dict[str, Any]) -> Any:
+    if payload:
+        return payload.get("payload", payload)
+    raw = config.get("payload")
+    payload_type = str(config_value(config, "payload_type", "json")).lower()
+    if payload_type == "string":
+        return "" if raw is None else str(raw)
+    if payload_type == "number":
+        try:
+            return float(raw)
+        except (TypeError, ValueError):
+            return 0
+    if payload_type == "boolean":
+        if isinstance(raw, bool):
+            return raw
+        return str(raw).strip().lower() in {"true", "1", "yes", "y", "on"}
+    if isinstance(raw, (dict, list, int, float, bool)):
+        return raw
+    try:
+        return json.loads(raw or "{}")
+    except Exception:
+        return raw
+
+
+async def execute_common_node(
+    node_type: str | None,
+    node: dict,
+    layout: dict | None,
+    config: dict,
+    payload: dict[str, Any],
+) -> NodeExecutionResult:
+    if node_type == "inject":
+        message = {
+            "topic": config.get("topic") or payload.get("topic"),
+            "payload": inject_payload(config, payload),
+        }
+        return NodeExecutionResult(True, None, {"status": "injected", "message": message})
+    if node_type == "debug":
+        if config.get("active") is False:
+            return NodeExecutionResult(True, None, {"status": "disabled"})
+        output = str(config_value(config, "output", "payload"))
+        if output == "full":
+            debug_value = payload
+        elif output == "message":
+            debug_value = payload.get("message", payload)
+        else:
+            debug_value = nested_value(payload, str(config_value(config, "property", "payload")))
+        return NodeExecutionResult(True, None, {"status": "debugged", "value": debug_value})
+    if node_type == "comment":
+        return NodeExecutionResult(True, None, {"status": "comment", "text": config.get("text") or node.get("title") or node.get("name") or ""})
+    if node_type in {"junction", "subflow"}:
+        return NodeExecutionResult(True, None, {"status": "passed", "node_type": node_type, "message": payload})
+    if node_type in {"catch", "status", "complete", "link in"}:
+        return NodeExecutionResult(
+            True,
+            None,
+            {
+                "status": "registered",
+                "node_type": node_type,
+                "scope": config.get("scope"),
+                "node_ids": config.get("node_ids") or [],
+            },
+        )
+    if node_type in {"link out", "link call"}:
+        link_id = str(config_value(config, "link_id", ""))
+        linked = []
+        if layout:
+            for candidate in layout.get("nodes", []):
+                candidate_config = candidate.get("config") if isinstance(candidate.get("config"), dict) else {}
+                candidate_type = node_type_from_record(candidate)
+                if candidate_type == "link in" and str(candidate_config.get("link_id") or "") == link_id:
+                    linked.append(candidate.get("node_id"))
+        return NodeExecutionResult(True, None, {"status": "linked", "node_type": node_type, "link_id": link_id, "target_node_ids": linked, "payload": payload})
+    return NodeExecutionResult(True, None, {"status": "queued"})