kailash 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

kailash/nodes/mixins/event_emitter.py

@@ -0,0 +1,201 @@
+"""
+Event Emitter Mixin for Nodes
+
+Provides event emission capabilities for nodes to integrate with the
+middleware layer for real-time monitoring and communication.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:
+    from kailash.middleware.events import EventStream
+
+logger = logging.getLogger(__name__)
+
+
+class EventEmitterMixin:
+    """
+    Mixin that adds event emission capabilities to nodes.
+
+    This mixin allows nodes to emit events that can be consumed by the
+    middleware layer for real-time monitoring, logging, and frontend updates.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._event_stream: Optional["EventStream"] = None
+        self._session_id: Optional[str] = None
+        self._workflow_id: Optional[str] = None
+        self._execution_id: Optional[str] = None
+
+    def set_event_context(
+        self,
+        event_stream: "EventStream",
+        session_id: str = None,
+        workflow_id: str = None,
+        execution_id: str = None,
+    ):
+        """Set the event context for this node."""
+        self._event_stream = event_stream
+        self._session_id = session_id
+        self._workflow_id = workflow_id
+        self._execution_id = execution_id
+
+    async def emit_node_started(self, inputs: Dict[str, Any] = None):
+        """Emit node started event."""
+        if self._event_stream:
+            try:
+                from kailash.middleware.events import EventType, NodeEvent
+
+                event = NodeEvent(
+                    type=EventType.NODE_STARTED,
+                    workflow_id=self._workflow_id,
+                    node_id=getattr(self, "name", "unknown"),
+                    node_type=self.__class__.__name__,
+                    node_name=getattr(self, "name", "unknown"),
+                    inputs=inputs or {},
+                    session_id=self._session_id,
+                )
+
+                await self._event_stream.emit(event)
+            except Exception as e:
+                logger.warning(f"Failed to emit node started event: {e}")
+
+    async def emit_node_completed(
+        self, outputs: Dict[str, Any] = None, execution_time_ms: float = None
+    ):
+        """Emit node completed event."""
+        if self._event_stream:
+            try:
+                from kailash.middleware.events import EventType, NodeEvent
+
+                event = NodeEvent(
+                    type=EventType.NODE_COMPLETED,
+                    workflow_id=self._workflow_id,
+                    node_id=getattr(self, "name", "unknown"),
+                    node_type=self.__class__.__name__,
+                    node_name=getattr(self, "name", "unknown"),
+                    outputs=outputs or {},
+                    execution_time_ms=execution_time_ms,
+                    session_id=self._session_id,
+                )
+
+                await self._event_stream.emit(event)
+            except Exception as e:
+                logger.warning(f"Failed to emit node completed event: {e}")
+
+    async def emit_node_failed(self, error: str):
+        """Emit node failed event."""
+        if self._event_stream:
+            try:
+                from kailash.middleware.events import EventType, NodeEvent
+
+                event = NodeEvent(
+                    type=EventType.NODE_FAILED,
+                    workflow_id=self._workflow_id,
+                    node_id=getattr(self, "name", "unknown"),
+                    node_type=self.__class__.__name__,
+                    node_name=getattr(self, "name", "unknown"),
+                    error=error,
+                    session_id=self._session_id,
+                )
+
+                await self._event_stream.emit(event)
+            except Exception as e:
+                logger.warning(f"Failed to emit node failed event: {e}")
+
+    async def emit_node_progress(self, progress_percent: float, message: str = None):
+        """Emit node progress event."""
+        if self._event_stream:
+            try:
+                from kailash.middleware.events import EventType, NodeEvent
+
+                event = NodeEvent(
+                    type=EventType.NODE_PROGRESS,
+                    workflow_id=self._workflow_id,
+                    node_id=getattr(self, "name", "unknown"),
+                    node_type=self.__class__.__name__,
+                    node_name=getattr(self, "name", "unknown"),
+                    metadata={"progress_percent": progress_percent, "message": message},
+                    session_id=self._session_id,
+                )
+
+                await self._event_stream.emit(event)
+            except Exception as e:
+                logger.warning(f"Failed to emit node progress event: {e}")
+
+    def has_event_stream(self) -> bool:
+        """Check if event stream is available."""
+        return self._event_stream is not None
+
+
+class EventAwareNode:
+    """
+    Enhanced node base class with built-in event emission.
+
+    This class can be used as a base class for nodes that want
+    automatic event emission during execution.
+    """
+
+    def __init__(self, *args, **kwargs):
+        # Initialize the mixin first
+        if hasattr(super(), "__init__"):
+            super().__init__(*args, **kwargs)
+
+        # Add event emission capabilities
+        self._event_mixin = EventEmitterMixin()
+
+    def set_event_context(self, *args, **kwargs):
+        """Delegate to mixin."""
+        self._event_mixin.set_event_context(*args, **kwargs)
+
+    async def emit_node_started(self, *args, **kwargs):
+        """Delegate to mixin."""
+        await self._event_mixin.emit_node_started(*args, **kwargs)
+
+    async def emit_node_completed(self, *args, **kwargs):
+        """Delegate to mixin."""
+        await self._event_mixin.emit_node_completed(*args, **kwargs)
+
+    async def emit_node_failed(self, *args, **kwargs):
+        """Delegate to mixin."""
+        await self._event_mixin.emit_node_failed(*args, **kwargs)
+
+    async def emit_node_progress(self, *args, **kwargs):
+        """Delegate to mixin."""
+        await self._event_mixin.emit_node_progress(*args, **kwargs)
+
+    def has_event_stream(self) -> bool:
+        """Delegate to mixin."""
+        return self._event_mixin.has_event_stream()
+
+
+def enable_events_for_node(node_instance, event_stream, **context):
+    """
+    Enable events for a node instance.
+
+    This function can be used to add event capabilities to existing
+    node instances without requiring them to inherit from EventAwareNode.
+
+    Args:
+        node_instance: The node instance to enhance
+        event_stream: The event stream to use
+        **context: Additional context (session_id, workflow_id, etc.)
+    """
+    # Add mixin to the instance
+    if not hasattr(node_instance, "_event_mixin"):
+        node_instance._event_mixin = EventEmitterMixin()
+
+        # Add methods to the instance
+        node_instance.set_event_context = node_instance._event_mixin.set_event_context
+        node_instance.emit_node_started = node_instance._event_mixin.emit_node_started
+        node_instance.emit_node_completed = (
+            node_instance._event_mixin.emit_node_completed
+        )
+        node_instance.emit_node_failed = node_instance._event_mixin.emit_node_failed
+        node_instance.emit_node_progress = node_instance._event_mixin.emit_node_progress
+        node_instance.has_event_stream = node_instance._event_mixin.has_event_stream
+
+    # Set the event context
+    node_instance.set_event_context(event_stream, **context)

kailash/nodes/mixins/mcp.py

@@ -5,9 +5,11 @@ allowing them to discover and use MCP tools without being an LLM agent.
 """
 
 import asyncio
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from kailash.mcp import MCPClient
+# Avoid circular import
+if TYPE_CHECKING:
+    from kailash.middleware.mcp import MiddlewareMCPClient as MCPClient
 
 
 class MCPCapabilityMixin:
@@ -43,10 +45,13 @@ class MCPCapabilityMixin:
         self._mcp_client = None
 
     @property
-    def mcp_client(self) -> MCPClient:
+    def mcp_client(self):
         """Get or create MCP client instance."""
         if self._mcp_client is None:
-            self._mcp_client = MCPClient()
+            # Lazy import to avoid circular dependency
+            from kailash.middleware.mcp import MiddlewareMCPClient
+
+            self._mcp_client = MiddlewareMCPClient()
         return self._mcp_client
 
     async def discover_mcp_tools(

kailash/nodes/mixins/security.py

@@ -0,0 +1,165 @@
+"""
+Security-related mixins for Kailash nodes.
+
+These mixins provide security, performance, and logging capabilities
+that can be mixed into any node class.
+"""
+
+import logging
+import time
+from functools import wraps
+from typing import Any, Dict, Optional
+
+
+class SecurityMixin:
+    """
+    Mixin that adds security features to nodes.
+
+    Provides:
+    - Security context management
+    - Audit logging capabilities
+    - Access control integration
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._security_context = {}
+        self._audit_enabled = kwargs.get("audit_enabled", True)
+        self._log_context = {}  # Initialize log context for log_with_context method
+
+    def set_security_context(self, context: Dict[str, Any]) -> None:
+        """Set security context for the node."""
+        self._security_context = context
+
+    def get_security_context(self) -> Dict[str, Any]:
+        """Get current security context."""
+        return self._security_context
+
+    def audit_log(self, action: str, details: Dict[str, Any]) -> None:
+        """Log an audit event."""
+        if self._audit_enabled:
+            # In a real implementation, this would integrate with AuditLogNode
+            print(f"[AUDIT] {action}: {details}")
+
+    def validate_and_sanitize_inputs(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate and sanitize input parameters."""
+        # Basic implementation - in production this would do more validation
+        sanitized = {}
+        for key, value in inputs.items():
+            if isinstance(value, str):
+                # Basic sanitization - remove leading/trailing whitespace
+                sanitized[key] = value.strip()
+            else:
+                sanitized[key] = value
+        return sanitized
+
+
+class PerformanceMixin:
+    """
+    Mixin that adds performance monitoring to nodes.
+
+    Provides:
+    - Execution time tracking
+    - Performance metrics collection
+    - SLA monitoring
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._performance_metrics = []
+        self._sla_target_ms = kwargs.get("sla_target_ms", 1000)
+
+    def track_performance(self, func):
+        """Decorator to track method performance."""
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            start_time = time.time()
+            try:
+                result = func(*args, **kwargs)
+                execution_time = (time.time() - start_time) * 1000  # Convert to ms
+                self._performance_metrics.append(
+                    {
+                        "method": func.__name__,
+                        "execution_time_ms": execution_time,
+                        "sla_met": execution_time <= self._sla_target_ms,
+                    }
+                )
+                return result
+            except Exception as e:
+                execution_time = (time.time() - start_time) * 1000
+                self._performance_metrics.append(
+                    {
+                        "method": func.__name__,
+                        "execution_time_ms": execution_time,
+                        "error": str(e),
+                    }
+                )
+                raise
+
+        return wrapper
+
+    def get_performance_metrics(self) -> list:
+        """Get collected performance metrics."""
+        return self._performance_metrics
+
+
+class LoggingMixin:
+    """
+    Mixin that adds enhanced logging capabilities to nodes.
+
+    Provides:
+    - Structured logging
+    - Context-aware logging
+    - Log level management
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self._log_context = {}
+
+    def set_log_context(self, **context):
+        """Set logging context."""
+        self._log_context.update(context)
+
+    def log_info(self, message: str, **extra):
+        """Log info message with context."""
+        self.logger.info(message, extra={**self._log_context, **extra})
+
+    def log_error(self, message: str, error: Optional[Exception] = None, **extra):
+        """Log error message with context."""
+        log_data = {**self._log_context, **extra}
+        if error:
+            log_data["error_type"] = type(error).__name__
+            log_data["error_message"] = str(error)
+        self.logger.error(message, extra=log_data)
+
+    def log_warning(self, message: str, **extra):
+        """Log warning message with context."""
+        self.logger.warning(message, extra={**self._log_context, **extra})
+
+    def log_error_with_traceback(
+        self, error: Exception, operation: str = "unknown"
+    ) -> None:
+        """Log an error with full traceback information."""
+        import traceback
+
+        self.log_error(
+            f"Operation failed: {operation}",
+            error=error,
+            traceback=traceback.format_exc(),
+        )
+
+    def log_node_execution(self, operation: str, **context) -> None:
+        """Log node execution information."""
+        self.log_info(f"Node operation: {operation}", **context)
+
+    def log_with_context(self, level: str, message: str, **context) -> None:
+        """Log a message with additional context."""
+        full_context = {**self._log_context, **context}
+        context_str = " | ".join(f"{k}={v}" for k, v in full_context.items())
+        full_message = f"{message} | {context_str}"
+
+        log_func = getattr(self.logger, level.lower())
+        log_func(full_message)

kailash/nodes/monitoring/__init__.py

@@ -0,0 +1,7 @@
+"""Monitoring and performance nodes for the Kailash SDK."""
+
+from .performance_benchmark import PerformanceBenchmarkNode
+
+__all__ = [
+    "PerformanceBenchmarkNode",
+]