kailash 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

kailash/workflow/builder.py

@@ -217,6 +217,58 @@ class WorkflowBuilder:
         self._metadata.update(kwargs)
         return self
 
+    def add_workflow_inputs(
+        self, input_node_id: str, input_mappings: dict
+    ) -> "WorkflowBuilder":
+        """
+        Map workflow-level inputs to a specific node's parameters.
+
+        Args:
+            input_node_id: The node that should receive workflow inputs
+            input_mappings: Dict mapping workflow input names to node parameter names
+
+        Returns:
+            Self for chaining
+        """
+        if input_node_id not in self.nodes:
+            raise WorkflowValidationError(f"Node '{input_node_id}' not found")
+
+        # Store input mappings in metadata
+        if "_workflow_inputs" not in self._metadata:
+            self._metadata["_workflow_inputs"] = {}
+        self._metadata["_workflow_inputs"][input_node_id] = input_mappings
+        return self
+
+    def update_node(self, node_id: str, config_updates: dict[str, Any]) -> "WorkflowBuilder":
+        """
+        Update the configuration of an existing node.
+        
+        This is essential for enterprise scenarios like:
+        - Dynamic environment-specific configuration
+        - Runtime parameter injection  
+        - Security context updates
+        - A/B testing and feature flags
+        
+        Args:
+            node_id: ID of the node to update
+            config_updates: Dictionary of configuration updates to apply
+            
+        Returns:
+            Self for chaining
+            
+        Raises:
+            WorkflowValidationError: If node doesn't exist
+        """
+        if node_id not in self.nodes:
+            raise WorkflowValidationError(f"Node '{node_id}' not found in workflow")
+            
+        # Deep merge the configuration updates
+        if "config" not in self.nodes[node_id]:
+            self.nodes[node_id]["config"] = {}
+            
+        self.nodes[node_id]["config"].update(config_updates)
+        return self
+
     def build(self, workflow_id: str | None = None, **kwargs) -> Workflow:
         """
         Build and return a Workflow instance.
@@ -338,32 +390,61 @@ class WorkflowBuilder:
             if key not in ["nodes", "connections"]:
                 builder._metadata[key] = value
 
-        # Add nodes
-        for node_config in config.get("nodes", []):
-            node_id = node_config.get("id")
-            node_type = node_config.get("type")
-            node_params = node_config.get("config", {})
-
-            if not node_id:
-                raise WorkflowValidationError("Node ID is required")
-            if not node_type:
-                raise WorkflowValidationError(
-                    f"Node type is required for node '{node_id}'"
-                )
+        # Add nodes - handle both dict and list formats
+        nodes_config = config.get("nodes", [])
+        
+        if isinstance(nodes_config, dict):
+            # Dict format: {node_id: {type: "...", parameters: {...}}}
+            for node_id, node_config in nodes_config.items():
+                node_type = node_config.get("type")
+                node_params = node_config.get("parameters", node_config.get("config", {}))
+                
+                if not node_type:
+                    raise WorkflowValidationError(
+                        f"Node type is required for node '{node_id}'"
+                    )
+                
+                builder.add_node(node_type, node_id, node_params)
+        else:
+            # List format: [{id: "...", type: "...", config: {...}}]
+            for node_config in nodes_config:
+                node_id = node_config.get("id")
+                node_type = node_config.get("type")
+                node_params = node_config.get("config", {})
+
+                if not node_id:
+                    raise WorkflowValidationError("Node ID is required")
+                if not node_type:
+                    raise WorkflowValidationError(
+                        f"Node type is required for node '{node_id}'"
+                    )
 
-            builder.add_node(node_type, node_id, node_params)
+                builder.add_node(node_type, node_id, node_params)
 
-        # Add connections
+        # Add connections - handle both full and simple formats
         for conn in config.get("connections", []):
+            # Try full format first: {from_node, from_output, to_node, to_input}
             from_node = conn.get("from_node")
             from_output = conn.get("from_output")
-            to_node = conn.get("to_node")
+            to_node = conn.get("to_node") 
             to_input = conn.get("to_input")
-
-            if not all([from_node, from_output, to_node, to_input]):
+            
+            # Handle simple format: {from, to} with default outputs/inputs
+            if not from_node:
+                from_node = conn.get("from")
+                from_output = conn.get("from_output", "result")  # Default output
+            if not to_node:
+                to_node = conn.get("to")
+                to_input = conn.get("to_input", "input")  # Default input
+
+            if not all([from_node, to_node]):
                 raise WorkflowValidationError(
-                    f"Invalid connection: missing required fields. Connection data: {conn}"
+                    f"Invalid connection: missing from_node and to_node. Connection data: {conn}"
                 )
+                
+            # Use defaults if not specified
+            from_output = from_output or "result"
+            to_input = to_input or "input"
 
             builder.add_connection(from_node, from_output, to_node, to_input)
 

kailash/workflow/builder_improvements.py

@@ -0,0 +1,207 @@
+"""
+WorkflowBuilder Improvements for Parameter Passing
+
+This module contains improvements to the WorkflowBuilder to handle
+parameter passing to nodes without incoming connections.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from kailash.workflow.builder import WorkflowBuilder
+from kailash.workflow.graph import Workflow
+
+
+class ImprovedWorkflowBuilder(WorkflowBuilder):
+    """Enhanced WorkflowBuilder that automatically handles parameter passing"""
+
+    def __init__(self):
+        super().__init__()
+        self.workflow_parameters: Dict[str, Any] = {}
+        self.parameter_mappings: Dict[str, Dict[str, str]] = {}
+
+    def set_workflow_parameters(self, **parameters) -> "ImprovedWorkflowBuilder":
+        """
+        Set default parameters that will be passed to all nodes.
+
+        Args:
+            **parameters: Key-value pairs of workflow-level parameters
+
+        Returns:
+            Self for chaining
+        """
+        self.workflow_parameters.update(parameters)
+        return self
+
+    def add_parameter_mapping(
+        self, node_id: str, mappings: Dict[str, str]
+    ) -> "ImprovedWorkflowBuilder":
+        """
+        Add parameter mappings for a specific node.
+
+        Args:
+            node_id: Node to configure
+            mappings: Dict mapping workflow param names to node param names
+
+        Returns:
+            Self for chaining
+        """
+        if node_id not in self.parameter_mappings:
+            self.parameter_mappings[node_id] = {}
+        self.parameter_mappings[node_id].update(mappings)
+        return self
+
+    def add_input_connection(
+        self, to_node: str, to_input: str, from_workflow_param: str
+    ) -> "ImprovedWorkflowBuilder":
+        """
+        Connect a workflow parameter directly to a node input.
+
+        Args:
+            to_node: Target node ID
+            to_input: Input parameter name on the node
+            from_workflow_param: Workflow parameter name
+
+        Returns:
+            Self for chaining
+        """
+        # Add a special connection type for workflow inputs
+        connection = {
+            "from_node": "__workflow_input__",
+            "from_output": from_workflow_param,
+            "to_node": to_node,
+            "to_input": to_input,
+            "is_workflow_input": True,
+        }
+        self.connections.append(connection)
+        return self
+
+    def build(self, workflow_id: str | None = None, **kwargs) -> Workflow:
+        """
+        Build the workflow with automatic parameter injection.
+
+        Returns:
+            Enhanced Workflow instance
+        """
+        # First, build the base workflow
+        workflow = super().build(workflow_id, **kwargs)
+
+        # Find nodes without incoming connections
+        nodes_with_inputs = set()
+        for conn in self.connections:
+            if not conn.get("is_workflow_input"):
+                nodes_with_inputs.add(conn["to_node"])
+
+        nodes_without_inputs = set(self.nodes.keys()) - nodes_with_inputs
+
+        # For each node without inputs, check if it needs workflow parameters
+        for node_id in nodes_without_inputs:
+            node = self.nodes[node_id]
+            node_instance = workflow.get_node(node_id)
+
+            if hasattr(node_instance, "get_parameters"):
+                params = node_instance.get_parameters()
+
+                # Check which required parameters are missing from config
+                for param_name, param_def in params.items():
+                    if param_def.required and param_name not in node["config"]:
+                        # Check if this parameter should come from workflow parameters
+                        if param_name in self.workflow_parameters:
+                            # Add to node config
+                            node["config"][param_name] = self.workflow_parameters[
+                                param_name
+                            ]
+                        elif node_id in self.parameter_mappings:
+                            # Check parameter mappings
+                            mapping = self.parameter_mappings[node_id]
+                            if param_name in mapping:
+                                workflow_param = mapping[param_name]
+                                if workflow_param in self.workflow_parameters:
+                                    node["config"][param_name] = (
+                                        self.workflow_parameters[workflow_param]
+                                    )
+
+        # Store workflow parameters in metadata for runtime reference
+        workflow._metadata["workflow_parameters"] = self.workflow_parameters
+        workflow._metadata["parameter_mappings"] = self.parameter_mappings
+
+        return workflow
+
+
+def create_user_login_workflow_improved(config: Dict[str, Any]) -> Workflow:
+    """
+    Example of creating a login workflow with proper parameter handling.
+    """
+    workflow = ImprovedWorkflowBuilder()
+
+    # Set workflow-level parameters that will be shared
+    workflow.set_workflow_parameters(
+        tenant_id="default", database_config=config["database_config"]
+    )
+
+    # Add user fetcher node
+    workflow.add_node(
+        "UserManagementNode",
+        "user_fetcher",
+        {
+            "operation": "get_user",
+            "identifier": "$.email",
+            "identifier_type": "email",
+            # tenant_id and database_config will be auto-injected
+        },
+    )
+
+    # Map workflow inputs to the first node
+    workflow.add_input_connection("user_fetcher", "email", "email")
+    workflow.add_input_connection("user_fetcher", "password", "password")
+
+    # Add other nodes...
+    workflow.add_node(
+        "PythonCodeNode",
+        "password_verifier",
+        {"code": "# Password verification code here"},
+    )
+
+    # Connect nodes
+    workflow.add_connection("user_fetcher", "result", "password_verifier", "input")
+
+    return workflow.build(name="user_login_improved")
+
+
+# Alternative approach: Fix in the existing WorkflowBuilder
+def patch_workflow_builder():
+    """
+    Monkey patch the existing WorkflowBuilder to handle parameters better.
+    """
+    original_build = WorkflowBuilder.build
+
+    def enhanced_build(self, workflow_id: str | None = None, **kwargs) -> Workflow:
+        # Build the workflow normally
+        workflow = original_build(self, workflow_id, **kwargs)
+
+        # Enhanced parameter handling
+        # Find nodes without incoming connections and inject common parameters
+        nodes_with_inputs = set()
+        for edge in workflow._graph.edges():
+            nodes_with_inputs.add(edge[1])  # target node
+
+        # Get all nodes
+        all_nodes = set(workflow._graph.nodes())
+        nodes_without_inputs = all_nodes - nodes_with_inputs
+
+        # Common parameters that should be injected
+        common_params = {
+            "tenant_id": "default",
+            "database_config": kwargs.get("database_config", {}),
+        }
+
+        for node_id in nodes_without_inputs:
+            if node_id in workflow._nodes:
+                node_instance = workflow._nodes[node_id]
+                # Update node config with common parameters if not already set
+                for param, value in common_params.items():
+                    if param not in node_instance.config:
+                        node_instance.config[param] = value
+
+        return workflow
+
+    WorkflowBuilder.build = enhanced_build

kailash/workflow/input_handling.py

@@ -0,0 +1,170 @@
+"""
+Workflow Input Handling Enhancement
+
+This module provides a solution for properly passing workflow-level parameters
+to nodes, especially those without incoming connections.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Set
+
+from kailash.workflow.graph import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowInputHandler:
+    """Handles workflow input parameter distribution to nodes"""
+
+    @staticmethod
+    def inject_workflow_parameters(
+        workflow: Workflow, parameters: Dict[str, Any]
+    ) -> None:
+        """
+        Inject workflow parameters into nodes that need them.
+
+        This method identifies nodes without incoming connections and ensures
+        they receive necessary parameters from the workflow input.
+
+        Args:
+            workflow: The workflow to process
+            parameters: Parameters passed to the workflow
+        """
+        # Find nodes without incoming connections
+        nodes_with_inputs = set()
+        for edge in workflow._graph.edges():
+            nodes_with_inputs.add(edge[1])  # target node
+
+        all_nodes = set(workflow._graph.nodes())
+        entry_nodes = all_nodes - nodes_with_inputs
+
+        logger.debug(f"Found entry nodes without inputs: {entry_nodes}")
+
+        # Process each entry node
+        for node_id in entry_nodes:
+            if node_id not in workflow._nodes:
+                continue
+
+            node_instance = workflow._nodes[node_id]
+            node_type = type(node_instance).__name__
+
+            logger.debug(f"Processing entry node '{node_id}' of type {node_type}")
+
+            # Get node's required parameters
+            if hasattr(node_instance, "get_parameters"):
+                node_params = node_instance.get_parameters()
+
+                for param_name, param_def in node_params.items():
+                    if param_def.required:
+                        # Check if parameter is already in node config
+                        if param_name not in node_instance.config:
+                            # Try to find it in workflow parameters
+                            if param_name in parameters:
+                                logger.info(
+                                    f"Injecting parameter '{param_name}' "
+                                    f"into node '{node_id}'"
+                                )
+                                node_instance.config[param_name] = parameters[
+                                    param_name
+                                ]
+                            # Special handling for common parameters
+                            elif (
+                                param_name == "tenant_id"
+                                and "tenant_id" not in parameters
+                            ):
+                                # Use default tenant if not specified
+                                node_instance.config[param_name] = "default"
+                                logger.info(
+                                    f"Using default tenant_id for node '{node_id}'"
+                                )
+                            elif param_name == "database_config":
+                                # Try to find database config in various places
+                                db_config = (
+                                    parameters.get("database_config")
+                                    or parameters.get("db_config")
+                                    or workflow._metadata.get("database_config")
+                                )
+                                if db_config:
+                                    node_instance.config[param_name] = db_config
+                                    logger.info(
+                                        f"Injecting database_config into node '{node_id}'"
+                                    )
+
+    @staticmethod
+    def create_input_mappings(
+        workflow: Workflow, mappings: Dict[str, Dict[str, str]]
+    ) -> None:
+        """
+        Create explicit mappings from workflow inputs to node parameters.
+
+        Args:
+            workflow: The workflow to configure
+            mappings: Dict of node_id -> {workflow_param: node_param} mappings
+        """
+        for node_id, param_mappings in mappings.items():
+            if node_id not in workflow._nodes:
+                logger.warning(f"Node '{node_id}' not found in workflow")
+                continue
+
+            node_instance = workflow._nodes[node_id]
+
+            # Store mappings in node metadata for runtime use
+            if "_input_mappings" not in node_instance.config:
+                node_instance.config["_input_mappings"] = {}
+
+            node_instance.config["_input_mappings"].update(param_mappings)
+            logger.info(
+                f"Created input mappings for node '{node_id}': {param_mappings}"
+            )
+
+
+def enhance_workflow_execution(original_execute):
+    """
+    Decorator to enhance workflow execution with parameter injection.
+
+    This wraps the workflow execution to ensure parameters are properly
+    distributed to nodes before execution begins.
+    """
+
+    def enhanced_execute(self, parameters: Dict[str, Any] = None, **kwargs):
+        # Inject parameters before execution
+        if parameters:
+            WorkflowInputHandler.inject_workflow_parameters(self, parameters)
+
+        # Call original execution
+        return original_execute(self, parameters, **kwargs)
+
+    return enhanced_execute
+
+
+# Example usage for fixing the login workflow
+def fix_login_workflow(workflow: Workflow, config: Dict[str, Any]) -> None:
+    """
+    Fix the login workflow to properly handle parameters.
+
+    Args:
+        workflow: The login workflow to fix
+        config: Application configuration
+    """
+    # Define input mappings for the user_fetcher node
+    mappings = {
+        "user_fetcher": {
+            "email": "identifier",  # Map workflow 'email' to node 'identifier'
+            "tenant_id": "tenant_id",
+            "database_config": "database_config",
+        }
+    }
+
+    # Apply mappings
+    WorkflowInputHandler.create_input_mappings(workflow, mappings)
+
+    # Set default values for common parameters
+    if "user_fetcher" in workflow._nodes:
+        node = workflow._nodes["user_fetcher"]
+        if "tenant_id" not in node.config:
+            node.config["tenant_id"] = "default"
+        if "database_config" not in node.config:
+            node.config["database_config"] = {
+                "connection_string": config.get("DATABASE_URL"),
+                "database_type": "postgresql",
+            }

{kailash-0.6.2.dist-info → kailash-0.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.6.2
+Version: 0.6.4
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -65,6 +65,19 @@ Requires-Dist: qrcode>=8.2
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: bcrypt>=4.3.0
 Requires-Dist: plotly>=6.2.0
+Requires-Dist: redis[asyncio]>=6.2.0
+Requires-Dist: faker>=37.4.0
+Requires-Dist: structlog>=25.4.0
+Requires-Dist: authlib>=1.6.0
+Requires-Dist: slowapi>=0.1.9
+Requires-Dist: limits>=5.4.0
+Requires-Dist: prometheus-client>=0.22.1
+Requires-Dist: opentelemetry-api>=1.34.1
+Requires-Dist: opentelemetry-sdk>=1.34.1
+Requires-Dist: passlib>=1.7.4
+Requires-Dist: pyotp>=2.9.0
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.55b1
+Requires-Dist: seaborn>=0.13.2
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"
@@ -99,16 +112,16 @@ Dynamic: requires-python
 
 ---
 
-## 🔥 Latest Release: v0.6.1 (January 26, 2025)
+## 🔥 Latest Release: v0.6.3 (July 5, 2025)
 
-**Critical patch fixing middleware compatibility issues from v0.6.0**
+**Comprehensive MCP Platform & Documentation Improvements**
 
-- 🚨 **Fixed**: All middleware components now use `.execute()` method
-- 🔧 **Fixed**: DataTransformer string transformation validation
-- 🧹 **Fixed**: EventStore async task cleanup preventing crashes
-- 🐳 **New**: Standardized Docker test environment (`./test-env`)
+- 🚀 **MCP Testing**: 407 tests with 100% pass rate across 8 MCP components
+- 📚 **Documentation**: Fixed 200+ code examples, all now execute correctly
+- 🏢 **Enterprise**: Complete MCP platform integration with production workflows
+- 🔧 **Platform**: Resolved namespace collision (kailash.mcp → kailash.mcp_server)
 
-[Full Changelog](changelogs/releases/v0.6.1-2025-01-26.md) | [Migration Guide](sdk-users/migration-guides/v0.6.0-to-v0.6.1-migration.md)
+[Full Changelog](changelogs/releases/v0.6.3-2025-07-05.md) | [Previous Release](changelogs/releases/v0.6.1-2025-01-26.md)
 
 ## ✨ Highlights