kailash 0.9.20__py3-none-any.whl → 0.9.22__py3-none-any.whl

kailash/__init__.py

@@ -52,7 +52,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.9.20"
+__version__ = "0.9.22"
 
 __all__ = [
     # Core workflow components

kailash/api/tests/test_workflow_api_404.py

@@ -0,0 +1,202 @@
+"""
+Tests for WorkflowAPI Custom 404 Handler
+
+Tests that WorkflowAPI provides helpful 404 error messages
+with available endpoints when wrong paths are accessed.
+
+These tests follow TDD: They will FAIL initially until the 404 handler is implemented.
+This is expected behavior - we write tests FIRST, then implement.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+
+from kailash.api.workflow_api import WorkflowAPI
+from kailash.workflow.builder import WorkflowBuilder
+
+
+@pytest.fixture
+def simple_workflow_api():
+    """Simple WorkflowAPI for testing"""
+    workflow = WorkflowBuilder()
+    workflow.add_node(
+        "PythonCodeNode", "test", {"code": "result = {'message': 'test'}"}
+    )
+    api = WorkflowAPI(workflow.build())
+    return api
+
+
+def test_404_returns_helpful_json(simple_workflow_api):
+    """Test that 404 errors return helpful JSON with available endpoints."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Try to access non-existent path
+    response = client.get("/nonexistent")
+
+    # Should return 404
+    assert response.status_code == 404
+
+    # Should be JSON
+    assert response.headers["content-type"] == "application/json"
+
+    # Should have helpful error message
+    data = response.json()
+    assert "error" in data or "detail" in data, "404 response should have error field"
+
+    # Should mention endpoints or provide helpful info
+    response_str = str(data).lower()
+    has_endpoint_info = (
+        "endpoint" in response_str
+        or "available" in response_str
+        or "path" in response_str
+    )
+    assert has_endpoint_info, "404 response should mention endpoints or paths"
+
+
+def test_404_lists_available_endpoints(simple_workflow_api):
+    """Test that 404 response includes list of available endpoints."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Try to access non-existent path
+    response = client.get("/invalid_path")
+
+    assert response.status_code == 404
+
+    data = response.json()
+
+    # Should have some reference to available endpoints
+    response_str = str(data)
+    endpoints = []
+
+    # Check if standard endpoints are mentioned
+    if "/execute" in response_str:
+        endpoints.append("/execute")
+    if "/workflow/info" in response_str or "/info" in response_str:
+        endpoints.append("/workflow/info")
+    if "/health" in response_str:
+        endpoints.append("/health")
+
+    # Should mention at least 2 of the 3 standard endpoints
+    assert (
+        len(endpoints) >= 2
+    ), f"404 response should mention available endpoints. Found: {endpoints}"
+
+
+def test_404_provides_helpful_hint(simple_workflow_api):
+    """Test that 404 response provides actionable hint."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Try wrong path
+    response = client.get("/wrong")
+
+    assert response.status_code == 404
+
+    data = response.json()
+    response_str = str(data).lower()
+
+    # Should have hint, message, or suggestion
+    has_helpful_content = (
+        "hint" in response_str
+        or "try" in response_str
+        or "use" in response_str
+        or "most common" in response_str
+        or "suggestion" in response_str
+        or "did you mean" in response_str
+    )
+
+    assert (
+        has_helpful_content
+    ), "404 response should provide helpful hints or suggestions"
+
+
+def test_404_includes_documentation_link(simple_workflow_api):
+    """Test that 404 response includes link to documentation."""
+    client = TestClient(simple_workflow_api.app)
+
+    response = client.get("/missing")
+
+    assert response.status_code == 404
+    data = response.json()
+
+    # Should have docs link or path
+    response_str = str(data).lower()
+    has_docs_reference = (
+        "docs" in response_str
+        or "documentation" in response_str
+        or "/docs" in response_str
+    )
+    assert has_docs_reference, "404 response should reference documentation"
+
+
+def test_404_handler_for_root_path(simple_workflow_api):
+    """Test 404 handler when accessing root path with wrong method."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Try to GET root (only POST is typically defined for execute)
+    response = client.get("/")
+
+    # Could be 404 or 405 Method Not Allowed
+    assert response.status_code in [
+        404,
+        405,
+    ], f"Expected 404 or 405, got {response.status_code}"
+
+    # If 404, should have helpful info
+    if response.status_code == 404:
+        data = response.json()
+        response_str = str(data).lower()
+
+        # Should mention execute or available methods
+        has_helpful_info = (
+            "execute" in response_str
+            or "post" in response_str
+            or "endpoint" in response_str
+        )
+        assert (
+            has_helpful_info
+        ), "404 on root should mention execute endpoint or POST method"
+
+
+def test_404_handler_preserves_fastapi_routes(simple_workflow_api):
+    """Test that valid routes still work after adding 404 handler."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Valid route should work
+    response = client.get("/health")
+
+    # Health endpoint should return 200
+    assert (
+        response.status_code == 200
+    ), "Valid routes should still work after adding 404 handler"
+
+    # Should return JSON
+    assert response.headers["content-type"] == "application/json"
+
+
+def test_404_response_format_consistency(simple_workflow_api):
+    """Test that 404 responses have consistent format."""
+    client = TestClient(simple_workflow_api.app)
+
+    # Try multiple invalid paths
+    paths = ["/invalid1", "/wrong/path", "/nonexistent/endpoint"]
+
+    for path in paths:
+        response = client.get(path)
+        assert response.status_code == 404
+
+        # All should return JSON
+        assert (
+            response.headers["content-type"] == "application/json"
+        ), f"404 response for {path} should be JSON"
+
+        # All should have error structure
+        data = response.json()
+        assert isinstance(
+            data, dict
+        ), f"404 response for {path} should be a JSON object"
+
+        # Should have at least one error-related field
+        has_error_field = any(key in data for key in ["error", "detail", "message"])
+        assert (
+            has_error_field
+        ), f"404 response for {path} should have error/detail/message field"

kailash/api/workflow_api.py

@@ -12,7 +12,7 @@ from typing import Any
 
 import uvicorn
 from fastapi import BackgroundTasks, FastAPI, HTTPException, Request
-from fastapi.responses import StreamingResponse
+from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel, Field
 
 from kailash.runtime.local import LocalRuntime
@@ -129,6 +129,38 @@ class WorkflowAPI:
     def _setup_routes(self):
         """Setup API routes dynamically based on workflow."""
 
+        # Custom 404 handler for helpful error messages
+        @self.app.exception_handler(404)
+        async def custom_404_handler(request: Request, exc):
+            """Provide helpful 404 error with available endpoints."""
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "error": "Endpoint not found",
+                    "path": request.url.path,
+                    "message": "The requested endpoint does not exist for this workflow.",
+                    "available_endpoints": [
+                        {
+                            "method": "POST",
+                            "path": "/execute",
+                            "description": "Execute the workflow with input parameters",
+                        },
+                        {
+                            "method": "GET",
+                            "path": "/workflow/info",
+                            "description": "Get workflow metadata and structure",
+                        },
+                        {
+                            "method": "GET",
+                            "path": "/health",
+                            "description": "Check workflow API health status",
+                        },
+                    ],
+                    "hint": "Most common: POST to /execute endpoint with JSON body containing 'inputs' field",
+                    "documentation": "/docs",
+                },
+            )
+
         # Root execution endpoint (convenience for direct workflow execution)
         @self.app.post("/")
         async def execute_workflow_root(

kailash/nodes/base.py

@@ -202,11 +202,13 @@ class Node(ABC):
             - Validates parameters are correctly specified
         """
         try:
-            self.id = kwargs.get("id", self.__class__.__name__)
+            # Use _node_id for internal node identifier (namespace separation)
+            # This prevents collision with user's 'id' parameter
+            self._node_id = kwargs.get("_node_id", self.__class__.__name__)
             self.metadata = kwargs.get(
                 "metadata",
                 NodeMetadata(
-                    id=self.id,
+                    id=self._node_id,  # NodeMetadata still uses 'id' internally
                     name=kwargs.get("name", self.__class__.__name__),
                     description=kwargs.get("description", self.__doc__ or ""),
                     version=kwargs.get("version", "1.0.0"),
@@ -214,7 +216,7 @@ class Node(ABC):
                     tags=kwargs.get("tags", set()),
                 ),
             )
-            self.logger = logging.getLogger(f"kailash.nodes.{self.id}")
+            self.logger = logging.getLogger(f"kailash.nodes.{self._node_id}")
 
             # Filter out internal fields from config with comprehensive parameter handling
             # Get parameter definitions once and cache for both filtering and validation
@@ -232,11 +234,12 @@ class Node(ABC):
 
             # Comprehensive parameter filtering: handle ALL potential conflicts
             # Fields that are always internal (never user parameters)
-            always_internal = {"metadata"}
+            always_internal = {"metadata", "_node_id"}
 
             # Fields that can be either internal or user parameters
+            # Note: 'id' removed from this list - users can now use 'id' freely
+            # since node identifier is now '_node_id'
             potentially_user_params = {
-                "id",
                 "name",
                 "description",
                 "version",
@@ -344,6 +347,32 @@ class Node(ABC):
             self._workflow_context = {}
         self._workflow_context[key] = value
 
+    @property
+    def id(self) -> str:
+        """
+        Backward compatibility property for node identifier.
+
+        Returns the node's identifier (_node_id). This property maintains
+        backward compatibility for code that accesses node.id.
+
+        The internal identifier is now _node_id to prevent namespace collision
+        with user's 'id' parameter.
+        """
+        return self._node_id
+
+    @id.setter
+    def id(self, value: str):
+        """
+        Setter for backward compatibility with code that sets node.id.
+
+        This allows graph.py and other code to set the node identifier
+        while internally using _node_id for namespace separation.
+
+        Args:
+            value: The node identifier to set
+        """
+        self._node_id = value
+
     @abstractmethod
     def get_parameters(self) -> dict[str, NodeParameter]:
         """Define the parameters this node accepts.

kailash/nodes/code/python.py

@@ -412,8 +412,11 @@ class CodeExecutor:
         # Check code safety first
         is_safe, violations, imports_found = self.check_code_safety(code)
 
-        # Sanitize inputs
-        sanitized_inputs = validate_node_parameters(inputs, self.security_config)
+        # Sanitize inputs with python_exec context
+        # Python code execution via exec() does not need shell metacharacter sanitization
+        sanitized_inputs = validate_node_parameters(
+            inputs, self.security_config, context="python_exec"
+        )
 
         # Create isolated namespace
         import builtins
@@ -572,8 +575,11 @@ class CodeExecutor:
         Raises:
             NodeExecutionError: If function execution fails
         """
-        # Sanitize inputs for security
-        sanitized_inputs = validate_node_parameters(inputs, self.security_config)
+        # Sanitize inputs for security with python_exec context
+        # Python function execution does not need shell metacharacter sanitization
+        sanitized_inputs = validate_node_parameters(
+            inputs, self.security_config, context="python_exec"
+        )
 
         try:
             # Get function signature

kailash/nodes/data/async_sql.py

@@ -3255,8 +3255,17 @@ class AsyncSQLDatabaseNode(AsyncNode):
 
     def _generate_pool_key(self) -> str:
         """Generate a unique key for connection pool sharing."""
-        # Create a unique key based on connection parameters
+        # Get event loop ID for isolation
+        try:
+            loop = asyncio.get_running_loop()
+            loop_id = str(id(loop))
+        except RuntimeError:
+            # No running loop (initialization phase)
+            loop_id = "no_loop"
+
+        # Create a unique key based on event loop and connection parameters
         key_parts = [
+            loop_id,  # Event loop isolation
             self.config.get("database_type", ""),
             self.config.get("connection_string", "")
             or (
@@ -3295,16 +3304,30 @@ class AsyncSQLDatabaseNode(AsyncNode):
                     ):
 
                         if self._pool_key in self._shared_pools:
-                            # Reuse existing pool
+                            # Validate pool's event loop is still running before reuse
                             adapter, ref_count = self._shared_pools[self._pool_key]
-                            self._shared_pools[self._pool_key] = (
-                                adapter,
-                                ref_count + 1,
-                            )
-                            self._adapter = adapter
-                            self._connected = True
-                            logger.debug(f"Using class-level shared pool for {self.id}")
-                            return self._adapter
+
+                            try:
+                                # Check if we have a running event loop
+                                pool_loop = asyncio.get_running_loop()
+                                # If we got here, loop is running - safe to reuse
+                                self._shared_pools[self._pool_key] = (
+                                    adapter,
+                                    ref_count + 1,
+                                )
+                                self._adapter = adapter
+                                self._connected = True
+                                logger.debug(
+                                    f"Using class-level shared pool for {self.id}"
+                                )
+                                return self._adapter
+                            except RuntimeError:
+                                # Loop is closed - remove stale pool
+                                logger.warning(
+                                    f"Removing stale pool for {self._pool_key} - event loop closed"
+                                )
+                                del self._shared_pools[self._pool_key]
+                                # Fall through to create new pool
 
                         # Create new shared pool
                         self._adapter = await self._create_adapter()
@@ -4000,8 +4023,51 @@ class AsyncSQLDatabaseNode(AsyncNode):
 
                 metrics["pools"].append(pool_info)
 
+            # Clean up stale pools from closed event loops
+            cleaned_pools = cls._cleanup_closed_loop_pools()
+            if cleaned_pools > 0:
+                metrics["cleaned_stale_pools"] = cleaned_pools
+
             return metrics
 
+    @classmethod
+    def _cleanup_closed_loop_pools(cls) -> int:
+        """
+        Clean up pools from closed event loops.
+
+        Returns:
+            Number of pools removed
+        """
+        removed_count = 0
+        keys_to_remove = []
+
+        for pool_key in list(cls._shared_pools.keys()):
+            # Extract loop ID from pool key (first part before "|")
+            parts = pool_key.split("|")
+            if len(parts) > 0:
+                loop_id_str = parts[0]
+
+                # Check if this pool's event loop is still running
+                try:
+                    current_loop = asyncio.get_running_loop()
+                    current_loop_id = str(id(current_loop))
+
+                    # If loop IDs don't match and pool is stale, mark for removal
+                    if loop_id_str != current_loop_id and loop_id_str != "no_loop":
+                        keys_to_remove.append(pool_key)
+                except RuntimeError:
+                    # No current loop - mark old pools for removal
+                    if loop_id_str != "no_loop":
+                        keys_to_remove.append(pool_key)
+
+        # Remove stale pools
+        for key in keys_to_remove:
+            if key in cls._shared_pools:
+                del cls._shared_pools[key]
+                removed_count += 1
+
+        return removed_count
+
     @classmethod
     async def clear_shared_pools(cls) -> None:
         """Clear all shared connection pools. Use with caution!"""

kailash/security.py

@@ -475,6 +475,7 @@ def sanitize_input(
     max_length: int = 10000,
     allowed_types: list[type] | None = None,
     config: SecurityConfig | None = None,
+    context: str = "generic",
 ) -> Any:
     """
     Sanitize input values to prevent injection attacks.
@@ -484,12 +485,22 @@ def sanitize_input(
         max_length: Maximum string length
         allowed_types: List of allowed types
         config: Security configuration
+        context: Execution context for context-aware sanitization.
+            - "generic": Default moderate sanitization (backward compatible)
+            - "python_exec": Python code execution (preserves shell metacharacters)
+            - "shell_exec": Shell command execution (removes all dangerous characters)
 
     Returns:
         Sanitized value
 
     Raises:
         SecurityError: If input fails validation
+
+    Note:
+        The context parameter allows for appropriate security measures based on
+        how the data will be used. Python code execution via exec() does not
+        need shell metacharacter sanitization since characters like $, ;, &, |
+        are regular Python string characters and not executed by a shell.
     """
     if config is None:
         config = get_security_config()
@@ -751,32 +762,59 @@ def sanitize_input(
         if len(value) > max_length:
             raise SecurityError(f"Input too long: {len(value)} > {max_length}")
 
-        # Remove potentially dangerous characters and patterns
-        sanitized = re.sub(r"[<>;&|`$()]", "", value)
-        # Remove script tags and javascript
-        sanitized = re.sub(
-            r"<script.*?</script>", "", sanitized, flags=re.IGNORECASE | re.DOTALL
-        )
-        sanitized = re.sub(r"javascript:", "", sanitized, flags=re.IGNORECASE)
+        # Context-aware sanitization
+        if context == "python_exec":
+            # Python execution context: Only remove XSS patterns, preserve shell metacharacters
+            # Python exec() does not execute shell commands, so $, ;, &, |, `, (, ) are safe
+            sanitized = re.sub(
+                r"<script.*?</script>", "", value, flags=re.IGNORECASE | re.DOTALL
+            )
+            sanitized = re.sub(r"javascript:", "", sanitized, flags=re.IGNORECASE)
+            # Remove only the most dangerous HTML tags for XSS prevention
+            sanitized = re.sub(
+                r"</?(?:script|iframe|object|embed).*?>",
+                "",
+                sanitized,
+                flags=re.IGNORECASE,
+            )
+        elif context == "shell_exec":
+            # Shell execution context: Remove all shell metacharacters
+            sanitized = re.sub(r"[<>;&|`$()]", "", value)
+            sanitized = re.sub(
+                r"<script.*?</script>", "", sanitized, flags=re.IGNORECASE | re.DOTALL
+            )
+            sanitized = re.sub(r"javascript:", "", sanitized, flags=re.IGNORECASE)
+        else:
+            # Generic context: Moderate sanitization (backward compatible)
+            # Remove only basic XSS patterns, preserve most characters
+            sanitized = re.sub(
+                r"<script.*?</script>", "", value, flags=re.IGNORECASE | re.DOTALL
+            )
+            sanitized = re.sub(r"javascript:", "", sanitized, flags=re.IGNORECASE)
+            # Remove angle brackets for basic XSS protection
+            sanitized = re.sub(r"[<>]", "", sanitized)
 
         if sanitized != value and config.enable_audit_logging:
-            logger.warning(f"Input sanitized: {value[:50]}... -> {sanitized[:50]}...")
+            logger.warning(
+                f"Input sanitized ({context}): {value[:50]}... -> {sanitized[:50]}..."
+            )
 
         return sanitized
 
     # Dictionary sanitization (recursive)
     if isinstance(value, dict):
         return {
-            sanitize_input(k, max_length, allowed_types, config): sanitize_input(
-                v, max_length, allowed_types, config
-            )
+            sanitize_input(
+                k, max_length, allowed_types, config, context
+            ): sanitize_input(v, max_length, allowed_types, config, context)
             for k, v in value.items()
         }
 
     # List sanitization (recursive)
     if isinstance(value, list):
         return [
-            sanitize_input(item, max_length, allowed_types, config) for item in value
+            sanitize_input(item, max_length, allowed_types, config, context)
+            for item in value
         ]
 
     return value
@@ -811,7 +849,9 @@ def create_secure_temp_dir(
 
 
 def validate_node_parameters(
-    parameters: dict[str, Any], config: SecurityConfig | None = None
+    parameters: dict[str, Any],
+    config: SecurityConfig | None = None,
+    context: str = "generic",
 ) -> dict[str, Any]:
     """
     Validate and sanitize node parameters.
@@ -819,6 +859,10 @@ def validate_node_parameters(
     Args:
         parameters: Node parameters to validate
         config: Security configuration
+        context: Execution context for context-aware sanitization
+            - "generic": Default moderate sanitization
+            - "python_exec": Python code execution (preserves shell metacharacters)
+            - "shell_exec": Shell command execution (removes all dangerous characters)
 
     Returns:
         Validated and sanitized parameters
@@ -833,20 +877,22 @@ def validate_node_parameters(
 
     for key, value in parameters.items():
         # Sanitize parameter key
-        clean_key = sanitize_input(key, config=config)
+        clean_key = sanitize_input(key, config=config, context=context)
 
         # Special handling for file paths
         if "path" in key.lower() or "file" in key.lower():
             if isinstance(value, (str, Path)):
                 validated_value = validate_file_path(value, config, f"parameter {key}")
             else:
-                validated_value = sanitize_input(value, config=config)
+                validated_value = sanitize_input(value, config=config, context=context)
         else:
-            validated_value = sanitize_input(value, config=config)
+            validated_value = sanitize_input(value, config=config, context=context)
 
         validated_params[clean_key] = validated_value
 
     if config.enable_audit_logging:
-        logger.info(f"Node parameters validated: {list(validated_params.keys())}")
+        logger.info(
+            f"Node parameters validated ({context}): {list(validated_params.keys())}"
+        )
 
     return validated_params

kailash/workflow/graph.py

@@ -154,19 +154,19 @@ class Workflow:
 
         try:
             # Handle different constructor patterns
-            if "name" in params and "id" not in params:
+            if "name" in params and "_node_id" not in params:
                 # Node expects 'name' parameter (like PythonCodeNode)
                 if "name" not in config:
                     config = config.copy()  # Don't modify original
                     config["name"] = node_id
                 return node_class(**config)
-            elif "id" in params:
-                # Node expects 'id' parameter (traditional pattern)
-                return node_class(id=node_id, **config)
+            elif "_node_id" in params:
+                # Node expects '_node_id' parameter (namespace-separated metadata)
+                return node_class(_node_id=node_id, **config)
             else:
                 # Fallback: try both patterns
                 try:
-                    return node_class(id=node_id, **config)
+                    return node_class(_node_id=node_id, **config)
                 except TypeError:
                     # Try with name parameter
                     config = config.copy()

{kailash-0.9.20.dist-info → kailash-0.9.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.20
+Version: 0.9.22
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -122,11 +122,18 @@ Dynamic: requires-python
 
 ---
 
-## 🔥 Latest Release: v0.9.20 (October 6, 2025)
+## 🔥 Latest Release: v0.9.21 (October 8, 2025)
 
-**Provider Registry Fix & Multi-Modal Support**
+**AsyncSQL Event Loop Isolation Fix**
 
 ### 🐛 Critical Bug Fixes
+- **Event Loop Isolation**: Fixed "Event loop is closed" errors in AsyncSQLDatabaseNode
+  - Automatic connection pool isolation per event loop
+  - Prevents pool sharing across different event loops (FastAPI, sequential workflows)
+  - Backward compatible - no code changes required
+  - <5% performance overhead
+
+### Previous Release: v0.9.20 (October 6, 2025)
 - **Mock Provider Bypass**: Removed hardcoded `if provider == "mock"` logic from LLMAgentNode
 - **Tool Execution Flow**: Unified provider response generation for all providers
 - **Provider Registry**: All providers now use consistent registry path

{kailash-0.9.20.dist-info → kailash-0.9.22.dist-info}/RECORD

@@ -1,10 +1,10 @@
-kailash/__init__.py,sha256=YNnr4CZ7_iAp9097f3LS6alh0M8H9Ls5XxI3w8aKL10,2928
+kailash/__init__.py,sha256=ZtUDcORH0Y5VBrpecs4mSSBKdt_N-ylzx-vJMSoj3sA,2928
 kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
 kailash/access_control.py,sha256=MjKtkoQ2sg1Mgfe7ovGxVwhAbpJKvaepPWr8dxOueMA,26058
 kailash/access_control_abac.py,sha256=FPfa_8PuDP3AxTjdWfiH3ntwWO8NodA0py9W8SE5dno,30263
 kailash/manifest.py,sha256=qzOmeMGWz20Sp4IJitSH9gTVbGng7hlimc96VTW4KI8,24814
 kailash/sdk_exceptions.py,sha256=MeFNmFzDzs5g9PveymivIBp1vN6PI7eenGv-Dj62Gog,10774
-kailash/security.py,sha256=GBU93tUXcTZGEjl0f9XXRlF3W-sSulhiatMZzv1dNqc,27228
+kailash/security.py,sha256=O6snw6rKFWntKN_W1QqYxxfI3HHm2Qd-2VRvrC7LU6s,29634
 kailash/access_control/__init__.py,sha256=ykR_zGJXQoCU_4gGNFbYzhVdUemxeAAoDQLhKIPVBGE,4018
 kailash/access_control/managers.py,sha256=Vg2inaZqR2GBXsySvPZcEqQtFHgF94z7A_wUHMtA3qA,14431
 kailash/access_control/rule_evaluators.py,sha256=niguhjThBjA0jIXvdKdGAXzdSM_bAd0ebphGgRrDFKU,15337
@@ -18,7 +18,8 @@ kailash/api/custom_nodes_secure.py,sha256=cMh1FbEtUAEoLmTb5ew_CeX5kjikBzmBsat1GO
 kailash/api/gateway.py,sha256=BVEKyC53JRnBkOyg3YXAPGDzLm3zon0vbO1xiM6yNxU,12540
 kailash/api/mcp_integration.py,sha256=xY5VjYXh4bFuNyyWBXEuTm4jjwUn8_9QxZpa4hh6a0Q,14521
 kailash/api/studio.py,sha256=8Gj3R3p_-EpJerkWYLyrqVzJprKOQmTmK-1EgiLoXMc,34892
-kailash/api/workflow_api.py,sha256=S1O_PRtTo2SSk47iUh4-uTh0WY1Tjbl1Gt54QIOLDmE,14330
+kailash/api/workflow_api.py,sha256=xRbvqKH-pVbZeV2NqT3pfP1ykXqX38BvT5uheeyw3Hg,15805
+kailash/api/tests/test_workflow_api_404.py,sha256=NDE-hu0pSCnn81Sbd6zHDF6ByEPXfO7WuwJnhkAZG6w,6301
 kailash/channels/__init__.py,sha256=9YpGEpFbNgZ4Fp8fG3F4hEX9X94UR-xbHAQM6b0O1z8,642
 kailash/channels/api_channel.py,sha256=stuJxNJRUobzj1CavwsHWVZWr2kYqyVLjv_ynt6Wy6A,14541
 kailash/channels/base.py,sha256=8-cUYAVMlO67BMZCZscShy0FPYAK31s9bxk0JXA9wIM,7825
@@ -157,7 +158,7 @@ kailash/monitoring/asyncsql_metrics.py,sha256=jj9M8D5qHoS3zEFfZYsUCWsy5kb-J5-iYV
 kailash/monitoring/metrics.py,sha256=SiAnL3o6K0QaJHgfAuWBa-0pTkW5zymhuPEsj4bgOgM,22022
 kailash/nodes/__init__.py,sha256=dBnEwrop0cPblHxSOtVWAKCDzhRtcyQVv9j_YGWxczQ,6410
 kailash/nodes/__init___original.py,sha256=p2KSo0dyUBCLClU123qpQ0tyv5S_36PTxosNyW58nyY,1031
-kailash/nodes/base.py,sha256=GR2E1fWf8j1yMvJic7m2NAih7kjY1NtoDi47hHwoZ40,85437
+kailash/nodes/base.py,sha256=gDAajw-T7ktbUYfruzfGtoXytT7YF2Cw-3iVkNoox-Y,86550
 kailash/nodes/base_async.py,sha256=whxepCiVplrltfzEQuabmnGCpEV5WgfqwgxbLdCyiDk,8864
 kailash/nodes/base_cycle_aware.py,sha256=Xpze9xZzLepWeLpi9Y3tMn1dm2LVv-omr5TSQuGTtWo,13377
 kailash/nodes/base_with_acl.py,sha256=ZfrkLPgrEBcNbG0LKvtq6glDxyOYOMRw3VXX4vWX6bI,11852
@@ -213,13 +214,13 @@ kailash/nodes/cache/cache_invalidation.py,sha256=IUvxrRj3K5EF29Z2EaKl7t6Uze_cssn
 kailash/nodes/cache/redis_pool_manager.py,sha256=GR82GCWxo_gAzRE-091OB6AhKre8CTwM3OoePLb2gvE,21574
 kailash/nodes/code/__init__.py,sha256=yhEwuMjUEPFfe6hMGMd4E4gZdLUuf2JEQ7knYapiM4o,1283
 kailash/nodes/code/async_python.py,sha256=Ai-iMpmz-sAori73JBk0wZtqmwtmF2GNPDxqB04I2Ck,37058
-kailash/nodes/code/python.py,sha256=rHBynVhV16G9AOQMZtLnpwTkp-wxsGe69BAjVZ4X6hg,70224
+kailash/nodes/code/python.py,sha256=RbZTXQMNnXXROXKkDYhvKPyYO_6nZ7tJ4EVOeoiABuc,70537
 kailash/nodes/compliance/__init__.py,sha256=6a_FL4ofc8MAVuZ-ARW5uYenZLS4mBFVM9AI2QsnoF8,214
 kailash/nodes/compliance/data_retention.py,sha256=90bH_eGwlcDzUdklAJeXQM-RcuLUGQFQ5fgHOK8a4qk,69443
 kailash/nodes/compliance/gdpr.py,sha256=ZMoHZjAo4QtGwtFCzGMrAUBFV3TbZOnJ5DZGZS87Bas,70548
 kailash/nodes/data/__init__.py,sha256=f0h4ysvXxlyFcNJLvDyXrgJ0ixwDF1cS0pJ2QNPakhg,5213
 kailash/nodes/data/async_connection.py,sha256=wfArHs9svU48bxGZIiixSV2YVn9cukNgEjagwTRu6J4,17250
-kailash/nodes/data/async_sql.py,sha256=9C-XRTDrzpVwFRrI13ym539UajT0Qgh9jmIjisDPi28,188864
+kailash/nodes/data/async_sql.py,sha256=34jUqCiUaNMVynCSteTIT8mZUs2SanZoKdsyyyZf51E,191567
 kailash/nodes/data/async_vector.py,sha256=HtwQLO25IXu8Vq80qzU8rMkUAKPQ2qM0x8YxjXHlygU,21005
 kailash/nodes/data/bulk_operations.py,sha256=WVopmosVkIlweFxVt3boLdCPc93EqpYyQ1Ez9mCIt0c,34453
 kailash/nodes/data/directory.py,sha256=fbfLqD_ijRubk-4xew3604QntPsyDxqaF4k6TpfyjDg,9923
@@ -410,7 +411,7 @@ kailash/workflow/cycle_profiler.py,sha256=aEWSCm0Xy15SjgLTpPooVJMzpFhtJWt4livR-3
 kailash/workflow/cycle_state.py,sha256=hzRUvciRreWfS56Cf7ZLQPit_mlPTQDoNTawh8yi-2s,10747
 kailash/workflow/cyclic_runner.py,sha256=Zo2Rakp-N5pPSarndYPdkkpWgY9yHpYrrpUh-znoCKQ,71246
 kailash/workflow/edge_infrastructure.py,sha256=lQDzs0-KdoCMqI4KAXAGbhHbwadM6t-ffJEWLlRuSNo,12448
-kailash/workflow/graph.py,sha256=zRpGLXeuwtuxFBvE7_16c_bB9yqZirM_uwtfD1_MY4g,59272
+kailash/workflow/graph.py,sha256=MhTHRwgsI6KvuLbchsoR10YKGEwCgbQot6t5-RLJdv8,59311
 kailash/workflow/input_handling.py,sha256=HrW--AmelYC8F18nkfmYlF_wXycA24RuNbDRjvM8rqk,6561
 kailash/workflow/mermaid_visualizer.py,sha256=CAbLWSL9H-QeRlPNpPOJ3uxIBdcBEtx_KHHrrCdReCU,22290
 kailash/workflow/migration.py,sha256=6WIGP5Y9kGgb0_3nLXVo8TPtuzsk66eoTSalWt7st_0,31463
@@ -423,10 +424,10 @@ kailash/workflow/templates.py,sha256=aZQzEPQD368nN0x0ICQlRKmAr2FqTxIOUa-7rb7EUWI
 kailash/workflow/type_inference.py,sha256=i1F7Yd_Z3elTXrthsLpqGbOnQBIVVVEjhRpI0HrIjd0,24492
 kailash/workflow/validation.py,sha256=LdbIPQSokCqSLfWTBhJR82pa_0va44pcVu9dpEM4rvY,45177
 kailash/workflow/visualization.py,sha256=nHBW-Ai8QBMZtn2Nf3EE1_aiMGi9S6Ui_BfpA5KbJPU,23187
-kailash-0.9.20.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
-kailash-0.9.20.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
-kailash-0.9.20.dist-info/METADATA,sha256=m_PViYPw0xnQ2Ijzwu778vb98XIpvZOksgeuMrq2tRY,23678
-kailash-0.9.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.9.20.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.9.20.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.9.20.dist-info/RECORD,,
+kailash-0.9.22.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
+kailash-0.9.22.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
+kailash-0.9.22.dist-info/METADATA,sha256=bsANyjL_bARSOE93lZ0J9ZjeXPsP7kQ28pSl6zFu8hQ,24027
+kailash-0.9.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.9.22.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.9.22.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.9.22.dist-info/RECORD,,