kailash 0.4.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

kailash/nodes/code/python.py

@@ -100,6 +100,7 @@ ALLOWED_MODULES = {
     "pathlib",  # For modern path operations
     "glob",  # For file pattern matching
     "xml",  # For XML processing
+    "uuid",  # For generating unique identifiers (safe, no I/O)
 }
 
 

kailash/nodes/data/async_sql.py

@@ -34,7 +34,8 @@ from decimal import Decimal
 from enum import Enum
 from typing import Any, AsyncIterator, Optional, Union
 
-from kailash.nodes.base import Node, NodeParameter, register_node
+from kailash.nodes.base import NodeParameter, register_node
+from kailash.nodes.base_async import AsyncNode
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError
 
 
@@ -204,16 +205,22 @@ class PostgreSQLAdapter(DatabaseAdapter):
                     query_params.append(value)
                 params = query_params
 
+            # Ensure params is a list/tuple for asyncpg
+            if params is None:
+                params = []
+            elif not isinstance(params, (list, tuple)):
+                params = [params]
+
             if fetch_mode == FetchMode.ONE:
-                row = await conn.fetchrow(query, *(params or []))
+                row = await conn.fetchrow(query, *params)
                 return self._convert_row(dict(row)) if row else None
             elif fetch_mode == FetchMode.ALL:
-                rows = await conn.fetch(query, *(params or []))
+                rows = await conn.fetch(query, *params)
                 return [self._convert_row(dict(row)) for row in rows]
             elif fetch_mode == FetchMode.MANY:
                 if not fetch_size:
                     raise ValueError("fetch_size required for MANY mode")
-                rows = await conn.fetch(query, *(params or []))
+                rows = await conn.fetch(query, *params)
                 return [self._convert_row(dict(row)) for row in rows[:fetch_size]]
             elif fetch_mode == FetchMode.ITERATOR:
                 raise NotImplementedError("Iterator mode not yet implemented")
@@ -425,7 +432,7 @@ class SQLiteAdapter(DatabaseAdapter):
 
 
 @register_node()
-class AsyncSQLDatabaseNode(Node):
+class AsyncSQLDatabaseNode(AsyncNode):
     """Asynchronous SQL database node for high-concurrency database operations.
 
     This node provides non-blocking database operations with connection pooling,
@@ -713,26 +720,6 @@ class AsyncSQLDatabaseNode(Node):
         except Exception as e:
             raise NodeExecutionError(f"Database query failed: {str(e)}")
 
-    def run(self, **inputs) -> dict[str, Any]:
-        """Synchronous run method - delegates to async_run."""
-        import asyncio
-
-        import nest_asyncio
-
-        try:
-            # Check if we're already in an event loop
-            loop = asyncio.get_running_loop()
-
-            # Apply nest_asyncio to allow nested event loops
-            nest_asyncio.apply()
-
-            # Now we can safely run even in an existing event loop
-            return asyncio.run(self.async_run(**inputs))
-
-        except RuntimeError:
-            # No event loop running, we can use asyncio.run() directly
-            return asyncio.run(self.async_run(**inputs))
-
     async def process(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Async process method for middleware compatibility."""
         return await self.async_run(**inputs)

kailash/nodes/data/sql.py

@@ -288,10 +288,10 @@ class SQLDatabaseNode(Node):
             ),
             "parameters": NodeParameter(
                 name="parameters",
-                type=list,
+                type=Any,  # Allow both list and dict for parameters
                 required=False,
-                default=[],
-                description="Query parameters for parameterized queries",
+                default=None,
+                description="Query parameters for parameterized queries (list for positional, dict for named)",
             ),
             "result_format": NodeParameter(
                 name="result_format",
@@ -367,7 +367,7 @@ class SQLDatabaseNode(Node):
         """
         # Extract validated inputs
         query = kwargs.get("query")
-        parameters = kwargs.get("parameters", [])
+        parameters = kwargs.get("parameters")
         result_format = kwargs.get("result_format", "dict")
         user_context = kwargs.get("user_context")
 
@@ -757,19 +757,28 @@ class SQLDatabaseNode(Node):
 
         import re
 
-        # Remove potential passwords from error messages
+        # Remove potential passwords from error messages, but be more selective
         patterns_to_mask = [
             # Connection string passwords
             (r"://[^:]+:[^@]+@", "://***:***@"),
-            # SQL query content (in some error messages)
-            (r"'[^']*'", "'***'"),
-            # Quoted strings that might contain sensitive data
-            (r'"[^"]*"', '"***"'),
+            # Password fields in SQL (case insensitive)
+            (r"password\s*=\s*['\"][^'\"]*['\"]", "password='***'", re.IGNORECASE),
+            # API keys and tokens in SQL
+            (
+                r"(api_key|token|secret)\s*=\s*['\"][^'\"]*['\"]",
+                r"\1='***'",
+                re.IGNORECASE,
+            ),
         ]
 
         sanitized = error_message
-        for pattern, replacement in patterns_to_mask:
-            sanitized = re.sub(pattern, replacement, sanitized)
+        for pattern_info in patterns_to_mask:
+            if len(pattern_info) == 3:
+                pattern, replacement, flags = pattern_info
+                sanitized = re.sub(pattern, replacement, sanitized, flags=flags)
+            else:
+                pattern, replacement = pattern_info
+                sanitized = re.sub(pattern, replacement, sanitized)
 
         return sanitized