kailash 0.6.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

kailash/nodes/ai/llm_agent.py

@@ -363,6 +363,13 @@ class LLMAgentNode(Node):
                 default={},
                 description="Configuration for tool execution behavior",
             ),
+            "use_real_mcp": NodeParameter(
+                name="use_real_mcp",
+                type=bool,
+                required=False,
+                default=True,
+                description="Use real MCP tool execution instead of mock execution",
+            ),
         }
 
     def run(self, **kwargs) -> dict[str, Any]:
@@ -629,12 +636,14 @@ class LLMAgentNode(Node):
             )
 
             # Retrieve MCP context if configured
-            mcp_context_data = self._retrieve_mcp_context(mcp_servers, mcp_context)
+            mcp_context_data = self._retrieve_mcp_context(
+                mcp_servers, mcp_context, kwargs
+            )
 
             # Discover MCP tools if enabled
             discovered_mcp_tools = []
             if auto_discover_tools and mcp_servers:
-                discovered_mcp_tools = self._discover_mcp_tools(mcp_servers)
+                discovered_mcp_tools = self._discover_mcp_tools(mcp_servers, kwargs)
                 # Merge MCP tools with existing tools
                 tools = self._merge_tools(tools, discovered_mcp_tools)
 
@@ -976,7 +985,7 @@ class LLMAgentNode(Node):
             return asyncio.run(coro)
 
     def _retrieve_mcp_context(
-        self, mcp_servers: list[dict], mcp_context: list[str]
+        self, mcp_servers: list[dict], mcp_context: list[str], kwargs: dict = None
     ) -> list[dict[str, Any]]:
         """
         Retrieve context from Model Context Protocol (MCP) servers.
@@ -1043,7 +1052,7 @@ class LLMAgentNode(Node):
         context_data = []
 
         # Check if we should use real MCP implementation
-        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp()
+        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp(kwargs)
 
         if use_real_mcp:
             # Use internal MCP client for real implementation
@@ -1224,14 +1233,25 @@ class LLMAgentNode(Node):
 
         return context_data
 
-    def _should_use_real_mcp(self) -> bool:
+    def _should_use_real_mcp(self, kwargs: dict = None) -> bool:
         """Check if real MCP implementation should be used."""
-        # Check environment variable or configuration
         import os
 
-        return os.environ.get("KAILASH_USE_REAL_MCP", "false").lower() == "true"
+        # 1. Check explicit parameter first (highest priority)
+        if kwargs and "use_real_mcp" in kwargs:
+            return kwargs["use_real_mcp"]
 
-    def _discover_mcp_tools(self, mcp_servers: list[dict]) -> list[dict[str, Any]]:
+        # 2. Check environment variable (fallback)
+        env_value = os.environ.get("KAILASH_USE_REAL_MCP", "").lower()
+        if env_value in ("true", "false"):
+            return env_value == "true"
+
+        # 3. Default to True (real MCP execution)
+        return True
+
+    def _discover_mcp_tools(
+        self, mcp_servers: list[dict], kwargs: dict = None
+    ) -> list[dict[str, Any]]:
         """
         Discover available tools from MCP servers.
 
@@ -1244,7 +1264,7 @@ class LLMAgentNode(Node):
         discovered_tools = []
 
         # Check if we should use real MCP implementation
-        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp()
+        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp(kwargs)
 
         if use_real_mcp:
             try:

kailash/nodes/api/__init__.py

@@ -23,7 +23,7 @@ import warnings
 from .auth import APIKeyNode, BasicAuthNode, OAuth2Node
 from .graphql import AsyncGraphQLClientNode, GraphQLClientNode
 from .http import AsyncHTTPRequestNode, HTTPRequestNode
-from .monitoring import HealthCheckNode
+from .monitoring import APIHealthCheckNode
 from .rate_limiting import (
     AsyncRateLimitedAPINode,
     RateLimitConfig,
@@ -71,7 +71,7 @@ __all__ = [
     "AsyncRateLimitedAPINode",
     "create_rate_limiter",
     # Monitoring and Security
-    "HealthCheckNode",
+    "APIHealthCheckNode",
     "SecurityScannerNode",
     # Backwards compatibility
     "HTTPClientNode",  # Deprecated alias

kailash/nodes/api/monitoring.py

@@ -13,7 +13,7 @@ from kailash.nodes.base import Node, NodeParameter, register_node
 
 
 @register_node()
-class HealthCheckNode(Node):
+class APIHealthCheckNode(Node):
     """
     Performs health checks on various system components and services.
 

kailash/nodes/base.py

@@ -1427,11 +1427,35 @@ class NodeRegistry:
             - Factory methods: Dynamic node creation
         """
         if node_name not in cls._nodes:
-            available_nodes = ", ".join(sorted(cls._nodes.keys()))
-            raise NodeConfigurationError(
-                f"Node '{node_name}' not found in registry. "
-                f"Available nodes: {available_nodes}"
-            )
+            available_nodes = sorted(cls._nodes.keys())
+
+            # Provide more helpful error message based on registry state
+            if not available_nodes:
+                # Registry is empty - likely a test isolation or import issue
+                raise NodeConfigurationError(
+                    f"Node '{node_name}' not found in registry. "
+                    f"The node registry is empty. This usually means:\n"
+                    f"  1. Nodes haven't been imported yet (try: import kailash.nodes)\n"
+                    f"  2. Test isolation cleared the registry without re-importing\n"
+                    f"  3. The node module containing '{node_name}' wasn't imported\n"
+                    f"Common nodes: PythonCodeNode, CSVReaderNode, SQLDatabaseNode, HTTPRequestNode"
+                )
+            else:
+                # Registry has nodes but not the requested one
+                nodes_list = ", ".join(available_nodes)
+
+                # Try to suggest similar node names
+                similar = [
+                    n
+                    for n in available_nodes
+                    if node_name.lower() in n.lower() or n.lower() in node_name.lower()
+                ]
+                suggestion = f"\nDid you mean: {', '.join(similar)}?" if similar else ""
+
+                raise NodeConfigurationError(
+                    f"Node '{node_name}' not found in registry. "
+                    f"Available nodes: {nodes_list}{suggestion}"
+                )
         return cls._nodes[node_name]
 
     @classmethod

kailash/nodes/base_async.py

@@ -46,10 +46,13 @@ class AsyncNode(Node):
     """
 
     def execute(self, **runtime_inputs) -> dict[str, Any]:
-        """Execute the node synchronously by running async code in a new event loop.
+        """Execute the node synchronously by running async code with proper event loop handling.
 
-        This override allows AsyncNode to work with synchronous runtimes like LocalRuntime
-        by wrapping the async execution in a synchronous interface.
+        This enhanced implementation handles all event loop scenarios:
+        1. No event loop: Create new one with asyncio.run()
+        2. Event loop running: Use ThreadPoolExecutor with isolated loop
+        3. Threaded contexts: Proper thread-safe execution
+        4. Windows compatibility: ProactorEventLoopPolicy support
 
         Args:
             **runtime_inputs: Runtime inputs for node execution
@@ -62,7 +65,9 @@ class AsyncNode(Node):
             NodeExecutionError: If execution fails
         """
         import asyncio
+        import concurrent.futures
         import sys
+        import threading
 
         # For sync execution, we always create a new event loop
         # This avoids complexity with nested loops and ensures clean execution
@@ -70,22 +75,57 @@ class AsyncNode(Node):
             # Windows requires special handling
             asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
 
+        # Check if we're in a thread without an event loop
+        current_thread = threading.current_thread()
+        is_main_thread = isinstance(current_thread, threading._MainThread)
+
         # Run the async method - handle existing event loop
         try:
             # Try to get current event loop
             loop = asyncio.get_running_loop()
+            # Event loop is running - need to run in separate thread
+            return self._execute_in_thread(**runtime_inputs)
         except RuntimeError:
-            # No event loop running, safe to use asyncio.run()
-            return asyncio.run(self.execute_async(**runtime_inputs))
-        else:
-            # Event loop is running, create a task
-            import concurrent.futures
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(
-                    asyncio.run, self.execute_async(**runtime_inputs)
-                )
-                return future.result()
+            # No event loop running
+            if is_main_thread:
+                # Main thread without loop - safe to use asyncio.run()
+                return asyncio.run(self.execute_async(**runtime_inputs))
+            else:
+                # Non-main thread without loop - create new loop
+                return self._execute_in_new_loop(**runtime_inputs)
+
+    def _execute_in_thread(self, **runtime_inputs) -> dict[str, Any]:
+        """Execute async code in a separate thread with its own event loop."""
+        import asyncio
+        import concurrent.futures
+
+        def run_in_new_loop():
+            """Run async code in a completely new event loop."""
+            # Create fresh event loop for this thread
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(self.execute_async(**runtime_inputs))
+            finally:
+                new_loop.close()
+                asyncio.set_event_loop(None)
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_in_new_loop)
+            return future.result()
+
+    def _execute_in_new_loop(self, **runtime_inputs) -> dict[str, Any]:
+        """Execute async code by creating a new event loop in current thread."""
+        import asyncio
+
+        # Create and set new event loop for this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(self.execute_async(**runtime_inputs))
+        finally:
+            loop.close()
+            asyncio.set_event_loop(None)
 
     def run(self, **kwargs) -> dict[str, Any]:
         """Synchronous run is not supported for AsyncNode.

kailash/nodes/code/async_python.py

@@ -783,7 +783,7 @@ class AsyncPythonCodeNode(AsyncNode):
                 "max_concurrent_tasks",
                 "max_memory_mb",
                 "imports",
-                "config",
+                # Note: "config" removed - it's a valid runtime parameter name
             }
             runtime_inputs = {k: v for k, v in kwargs.items() if k not in config_params}
 

kailash/nodes/code/python.py

@@ -94,6 +94,7 @@ ALLOWED_MODULES = {
     "matplotlib",
     "seaborn",
     "plotly",
+    "array",  # Required by numpy internally
     # File processing modules
     "csv",  # For CSV file processing
     "mimetypes",  # For MIME type detection
@@ -419,12 +420,55 @@ class CodeExecutor:
         }
 
         # Add allowed modules
-        for module_name in self.allowed_modules:
-            try:
-                module = importlib.import_module(module_name)
-                namespace[module_name] = module
-            except ImportError:
-                logger.warning(f"Module {module_name} not available")
+        # Check if we're running under coverage to avoid instrumentation conflicts
+        import sys
+
+        if "coverage" in sys.modules:
+            # Under coverage, use lazy loading for problematic modules
+            problematic_modules = {
+                "numpy",
+                "scipy",
+                "sklearn",
+                "pandas",
+                "matplotlib",
+                "seaborn",
+                "plotly",
+                "array",
+            }
+            safe_modules = self.allowed_modules - problematic_modules
+
+            # Eagerly load safe modules
+            for module_name in safe_modules:
+                try:
+                    module = importlib.import_module(module_name)
+                    namespace[module_name] = module
+                except ImportError:
+                    logger.warning(f"Module {module_name} not available")
+
+            # Add lazy loader for problematic modules
+            class LazyModuleLoader:
+                def __getattr__(self, name):
+                    if name in problematic_modules:
+                        return importlib.import_module(name)
+                    raise AttributeError(f"Module {name} not found")
+
+            # Make problematic modules available through lazy loading
+            for module_name in problematic_modules:
+                try:
+                    # Try to import the module directly
+                    module = importlib.import_module(module_name)
+                    namespace[module_name] = module
+                except ImportError:
+                    # If import fails, use lazy loader as fallback
+                    namespace[module_name] = LazyModuleLoader()
+        else:
+            # Normal operation - eagerly load all modules
+            for module_name in self.allowed_modules:
+                try:
+                    module = importlib.import_module(module_name)
+                    namespace[module_name] = module
+                except ImportError:
+                    logger.warning(f"Module {module_name} not available")
 
         # Add sanitized inputs
         namespace.update(sanitized_inputs)

kailash/nodes/data/async_sql.py

@@ -431,6 +431,7 @@ class PostgreSQLAdapter(DatabaseAdapter):
         fetch_mode: FetchMode = FetchMode.ALL,
         fetch_size: Optional[int] = None,
         transaction: Optional[Any] = None,
+        parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query and return results."""
         # Convert dict params to positional for asyncpg
@@ -440,8 +441,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
             import json
 
             query_params = []
+            param_names = []  # Track parameter names for type mapping
             for i, (key, value) in enumerate(params.items(), 1):
                 query = query.replace(f":{key}", f"${i}")
+                param_names.append(key)
                 # For PostgreSQL, lists should remain as lists for array operations
                 # Only convert dicts to JSON strings
                 if isinstance(value, dict):
@@ -449,6 +452,24 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 query_params.append(value)
             params = query_params
 
+            # Apply parameter type casts if provided
+            if parameter_types:
+                # Build a query with explicit type casts
+                for i, param_name in enumerate(param_names, 1):
+                    if param_name in parameter_types:
+                        pg_type = parameter_types[param_name]
+                        # Replace $N with $N::type in the query
+                        query = query.replace(f"${i}", f"${i}::{pg_type}")
+
+        else:
+            # For positional params, apply type casts if provided
+            if parameter_types and isinstance(params, (list, tuple)):
+                # Build query with type casts for positional parameters
+                for i, param_type in parameter_types.items():
+                    if isinstance(i, int) and 0 <= i < len(params):
+                        # Replace $N with $N::type
+                        query = query.replace(f"${i+1}", f"${i+1}::{param_type}")
+
         # Ensure params is a list/tuple for asyncpg
         if params is None:
             params = []
@@ -1270,6 +1291,13 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 default=False,
                 description="Whether to allow administrative SQL commands (CREATE, DROP, etc.)",
             ),
+            NodeParameter(
+                name="parameter_types",
+                type=dict,
+                required=False,
+                default=None,
+                description="Optional PostgreSQL type hints for parameters (e.g., {'role_id': 'text', 'metadata': 'jsonb'})",
+            ),
             NodeParameter(
                 name="retry_config",
                 type=Any,
@@ -1532,6 +1560,9 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 "result_format", self.config.get("result_format", "dict")
             )
             user_context = inputs.get("user_context")
+            parameter_types = inputs.get(
+                "parameter_types", self.config.get("parameter_types")
+            )
 
             if not query:
                 raise NodeExecutionError("No query provided")
@@ -1576,8 +1607,12 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 fetch_mode=fetch_mode,
                 fetch_size=fetch_size,
                 user_context=user_context,
+                parameter_types=parameter_types,
             )
 
+            # Ensure all data is JSON-serializable (safety net for adapter inconsistencies)
+            result = self._ensure_serializable(result)
+
             # Format results based on requested format
             formatted_data = self._format_results(result, result_format)
 
@@ -1795,6 +1830,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
         fetch_mode: FetchMode,
         fetch_size: Optional[int],
         user_context: Any = None,
+        parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query with retry logic for transient failures.
 
@@ -1823,6 +1859,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
                     params=params,
                     fetch_mode=fetch_mode,
                     fetch_size=fetch_size,
+                    parameter_types=parameter_types,
                 )
 
                 # Apply data masking if access control is enabled
@@ -2010,6 +2047,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
         params: Any,
         fetch_mode: FetchMode,
         fetch_size: Optional[int],
+        parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query with automatic transaction management.
 
@@ -2034,6 +2072,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 fetch_mode=fetch_mode,
                 fetch_size=fetch_size,
                 transaction=self._active_transaction,
+                parameter_types=parameter_types,
             )
         elif self._transaction_mode == "auto":
             # Auto-transaction mode
@@ -2045,6 +2084,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
                     fetch_mode=fetch_mode,
                     fetch_size=fetch_size,
                     transaction=transaction,
+                    parameter_types=parameter_types,
                 )
                 await adapter.commit_transaction(transaction)
                 return result
@@ -2058,6 +2098,7 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 params=params,
                 fetch_mode=fetch_mode,
                 fetch_size=fetch_size,
+                parameter_types=parameter_types,
             )
 
     @classmethod
@@ -2460,6 +2501,55 @@ class AsyncSQLDatabaseNode(AsyncNode):
 
         return modified_query, param_dict
 
+    def _ensure_serializable(self, data: Any) -> Any:
+        """Ensure all data types are JSON-serializable.
+
+        This is a safety net for cases where adapter _convert_row might not be called
+        or might miss certain data types. It recursively processes the data structure
+        to ensure datetime objects and other non-JSON-serializable types are converted.
+
+        Args:
+            data: Raw data from database adapter
+
+        Returns:
+            JSON-serializable data structure
+        """
+        if data is None:
+            return None
+        elif isinstance(data, bool):
+            return data
+        elif isinstance(data, (int, float, str)):
+            return data
+        elif isinstance(data, datetime):
+            return data.isoformat()
+        elif isinstance(data, date):
+            return data.isoformat()
+        elif hasattr(data, "total_seconds"):  # timedelta
+            return data.total_seconds()
+        elif isinstance(data, Decimal):
+            return float(data)
+        elif isinstance(data, bytes):
+            import base64
+
+            return base64.b64encode(data).decode("utf-8")
+        elif hasattr(data, "__str__") and hasattr(data, "hex"):  # UUID-like objects
+            return str(data)
+        elif isinstance(data, dict):
+            return {
+                key: self._ensure_serializable(value) for key, value in data.items()
+            }
+        elif isinstance(data, (list, tuple)):
+            return [self._ensure_serializable(item) for item in data]
+        else:
+            # For any other type, try to convert to string as fallback
+            try:
+                # Test if it's already JSON serializable
+                json.dumps(data)
+                return data
+            except (TypeError, ValueError):
+                # Not serializable, convert to string
+                return str(data)
+
     def _format_results(self, data: list[dict], result_format: str) -> Any:
         """Format query results according to specified format.