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

kailash/runtime/local.py

@@ -40,8 +40,8 @@ from datetime import UTC, datetime
 from typing import Any, Optional
 
 import networkx as nx
-
 from kailash.nodes import Node
+from kailash.runtime.parameter_injector import WorkflowParameterInjector
 from kailash.sdk_exceptions import (
     RuntimeExecutionError,
     WorkflowExecutionError,
@@ -135,7 +135,7 @@ class LocalRuntime:
         self,
         workflow: Workflow,
         task_manager: TaskManager | None = None,
-        parameters: dict[str, dict[str, Any]] | None = None,
+        parameters: dict[str, dict[str, Any]] | dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], str | None]:
         """Execute a workflow with unified enterprise capabilities.
 
@@ -172,7 +172,7 @@ class LocalRuntime:
         self,
         workflow: Workflow,
         task_manager: TaskManager | None = None,
-        parameters: dict[str, dict[str, Any]] | None = None,
+        parameters: dict[str, dict[str, Any]] | dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], str | None]:
         """Execute a workflow asynchronously (for AsyncLocalRuntime compatibility).
 
@@ -197,7 +197,7 @@ class LocalRuntime:
         self,
         workflow: Workflow,
         task_manager: TaskManager | None = None,
-        parameters: dict[str, dict[str, Any]] | None = None,
+        parameters: dict[str, dict[str, Any]] | dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], str | None]:
         """Execute workflow synchronously when already in an event loop.
 
@@ -257,7 +257,7 @@ class LocalRuntime:
         self,
         workflow: Workflow,
         task_manager: TaskManager | None = None,
-        parameters: dict[str, dict[str, Any]] | None = None,
+        parameters: dict[str, dict[str, Any]] | dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], str | None]:
         """Core async execution implementation with enterprise features.
 
@@ -292,8 +292,13 @@ class LocalRuntime:
             if self.enable_security and self.user_context:
                 self._check_workflow_access(workflow)
 
+            # Transform workflow-level parameters if needed
+            processed_parameters = self._process_workflow_parameters(
+                workflow, parameters
+            )
+
             # Validate workflow with runtime parameters (Session 061)
-            workflow.validate(runtime_parameters=parameters)
+            workflow.validate(runtime_parameters=processed_parameters)
 
             # Enterprise Audit: Log workflow execution start
             if self.enable_audit:
@@ -302,7 +307,7 @@ class LocalRuntime:
                     {
                         "workflow_id": workflow.workflow_id,
                         "user_context": self._serialize_user_context(),
-                        "parameters": parameters,
+                        "parameters": processed_parameters,
                     },
                 )
 
@@ -315,7 +320,7 @@ class LocalRuntime:
                     run_id = task_manager.create_run(
                         workflow_name=workflow.name,
                         metadata={
-                            "parameters": parameters,
+                            "parameters": processed_parameters,
                             "debug": self.debug,
                             "runtime": "unified_enterprise",
                             "enterprise_features": self._execution_context,
@@ -335,7 +340,7 @@ class LocalRuntime:
                 try:
                     # Pass run_id to cyclic executor if available
                     cyclic_results, cyclic_run_id = self.cyclic_executor.execute(
-                        workflow, parameters, task_manager, run_id
+                        workflow, processed_parameters, task_manager, run_id
                     )
                     results = cyclic_results
                     # Update run_id if task manager is being used
@@ -354,7 +359,7 @@ class LocalRuntime:
                     workflow=workflow,
                     task_manager=task_manager,
                     run_id=run_id,
-                    parameters=parameters or {},
+                    parameters=processed_parameters or {},
                 )
 
             # Enterprise Audit: Log successful completion
@@ -543,6 +548,14 @@ class LocalRuntime:
                 # Update node config with parameters (Session 061: direct config update)
                 {**node_instance.config, **parameters.get(node_id, {})}
                 node_instance.config.update(parameters.get(node_id, {}))
+                
+                # ENTERPRISE PARAMETER INJECTION FIX: Injected parameters should override connection inputs
+                # This ensures workflow parameters take precedence over connection inputs for the same parameter names
+                injected_params = parameters.get(node_id, {})
+                if injected_params:
+                    inputs.update(injected_params)
+                    if self.debug:
+                        self.logger.debug(f"Applied parameter injections for {node_id}: {list(injected_params.keys())}")
 
                 if self.debug:
                     self.logger.debug(f"Node {node_id} inputs: {inputs}")
@@ -856,10 +869,7 @@ class LocalRuntime:
 
         try:
             # Use existing AccessControlManager pattern
-            from kailash.access_control import (
-                WorkflowPermission,
-                get_access_control_manager,
-            )
+            from kailash.access_control import WorkflowPermission, get_access_control_manager
 
             if self._access_control_manager is None:
                 self._access_control_manager = get_access_control_manager()
@@ -961,3 +971,141 @@ class LocalRuntime:
         except Exception as e:
             self.logger.warning(f"Failed to serialize user context: {e}")
             return {"user_context": str(self.user_context)}
+
+    def _process_workflow_parameters(
+        self,
+        workflow: Workflow,
+        parameters: dict[str, dict[str, Any]] | dict[str, Any] | None = None,
+    ) -> dict[str, dict[str, Any]] | None:
+        """Process workflow parameters to handle both formats intelligently.
+
+        This method detects whether parameters are in workflow-level format
+        (flat dictionary) or node-specific format (nested dictionary) and
+        transforms them appropriately for execution.
+
+        ENTERPRISE ENHANCEMENT: Handles mixed format parameters where both
+        node-specific and workflow-level parameters are present in the same
+        parameter dictionary - critical for enterprise production workflows.
+
+        Args:
+            workflow: The workflow being executed
+            parameters: Either workflow-level, node-specific, or MIXED format parameters
+
+        Returns:
+            Node-specific parameters ready for execution with workflow-level
+            parameters properly injected
+        """
+        if not parameters:
+            return None
+
+        # ENTERPRISE FIX: Handle mixed format parameters
+        # Extract node-specific and workflow-level parameters separately
+        node_specific_params, workflow_level_params = self._separate_parameter_formats(
+            parameters, workflow
+        )
+
+        # Start with node-specific parameters
+        result = node_specific_params.copy() if node_specific_params else {}
+
+        # If we have workflow-level parameters, inject them
+        if workflow_level_params:
+            injector = WorkflowParameterInjector(workflow, debug=self.debug)
+
+            # Transform workflow parameters to node-specific format
+            injected_params = injector.transform_workflow_parameters(
+                workflow_level_params
+            )
+
+            # Merge injected parameters with existing node-specific parameters
+            # IMPORTANT: Node-specific parameters take precedence over workflow-level
+            for node_id, node_params in injected_params.items():
+                if node_id not in result:
+                    result[node_id] = {}
+                # First set workflow-level parameters, then override with node-specific
+                for param_name, param_value in node_params.items():
+                    if param_name not in result[node_id]:  # Only if not already set
+                        result[node_id][param_name] = param_value
+
+            # Validate the transformation
+            warnings = injector.validate_parameters(workflow_level_params)
+            if warnings and self.debug:
+                for warning in warnings:
+                    self.logger.warning(f"Parameter validation: {warning}")
+
+        return result if result else None
+
+    def _separate_parameter_formats(
+        self, parameters: dict[str, Any], workflow: Workflow
+    ) -> tuple[dict[str, dict[str, Any]], dict[str, Any]]:
+        """Separate mixed format parameters into node-specific and workflow-level.
+
+        ENTERPRISE CAPABILITY: Intelligently separates complex enterprise parameter
+        patterns where both node-specific and workflow-level parameters coexist.
+
+        Args:
+            parameters: Mixed format parameters
+            workflow: The workflow being executed
+
+        Returns:
+            Tuple of (node_specific_params, workflow_level_params)
+        """
+        node_specific_params = {}
+        workflow_level_params = {}
+
+        # Get node IDs for classification
+        node_ids = set(workflow.graph.nodes()) if workflow else set()
+
+        for key, value in parameters.items():
+            # Node-specific parameter: key is a node ID and value is a dict
+            if key in node_ids and isinstance(value, dict):
+                node_specific_params[key] = value
+            # Workflow-level parameter: key is not a node ID or value is not a dict
+            else:
+                workflow_level_params[key] = value
+
+        if self.debug:
+            self.logger.debug(
+                f"Separated parameters: "
+                f"node_specific={list(node_specific_params.keys())}, "
+                f"workflow_level={list(workflow_level_params.keys())}"
+            )
+
+        return node_specific_params, workflow_level_params
+
+    def _is_node_specific_format(
+        self, parameters: dict[str, Any], workflow: Workflow = None
+    ) -> bool:
+        """Detect if parameters are in node-specific format.
+
+        Node-specific format has structure: {node_id: {param: value}}
+        Workflow-level format has structure: {param: value}
+
+        Args:
+            parameters: Parameters to check
+            workflow: Optional workflow for node ID validation
+
+        Returns:
+            True if node-specific format, False if workflow-level
+        """
+        if not parameters:
+            return True
+
+        # Get node IDs if workflow provided
+        node_ids = set(workflow.graph.nodes()) if workflow else set()
+
+        # If any key is a node ID and its value is a dict, it's node-specific
+        for key, value in parameters.items():
+            if key in node_ids and isinstance(value, dict):
+                return True
+
+        # Additional heuristic: if all values are dicts and keys look like IDs
+        all_dict_values = all(isinstance(v, dict) for v in parameters.values())
+        keys_look_like_ids = any(
+            "_" in k or k.startswith("node") or k in node_ids for k in parameters.keys()
+        )
+
+        if all_dict_values and keys_look_like_ids:
+            return True
+
+        # Default to workflow-level format
+        return False

kailash/runtime/parameter_injection.py

@@ -0,0 +1,425 @@
+"""Parameter injection framework for enterprise nodes.
+
+This module provides a framework for handling runtime parameter injection
+in enterprise nodes that traditionally require initialization-time configuration.
+It bridges the gap between static configuration and dynamic workflow parameters.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class ParameterInjectionMixin:
+    """Mixin to add parameter injection capabilities to nodes.
+
+    This mixin allows nodes to defer configuration until runtime,
+    enabling workflow-level parameter injection for connection parameters.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize with deferred configuration support."""
+        # Store original kwargs for deferred initialization
+        self._deferred_config = kwargs.copy()
+        self._is_initialized = False
+        self._runtime_config = {}
+        super().__init__(*args, **kwargs)
+
+    def set_runtime_parameters(self, **runtime_params: Any) -> None:
+        """Set runtime parameters for deferred initialization.
+
+        Args:
+            **runtime_params: Runtime parameters to use for configuration
+        """
+        self._runtime_config.update(runtime_params)
+        logger.debug(
+            f"Set runtime parameters for {self.__class__.__name__}: {list(runtime_params.keys())}"
+        )
+
+    def get_effective_config(self) -> Dict[str, Any]:
+        """Get effective configuration combining init-time and runtime parameters.
+
+        Returns:
+            Combined configuration with runtime parameters taking precedence
+        """
+        effective_config = self._deferred_config.copy()
+        effective_config.update(self._runtime_config)
+        return effective_config
+
+    def initialize_with_runtime_config(self) -> None:
+        """Initialize the node with runtime configuration.
+
+        Should be called by subclasses when they need to set up connections
+        or other resources that depend on runtime parameters.
+        """
+        if not self._is_initialized:
+            self._perform_initialization(self.get_effective_config())
+            self._is_initialized = True
+
+    @abstractmethod
+    def _perform_initialization(self, config: Dict[str, Any]) -> None:
+        """Perform actual initialization with effective configuration.
+
+        Args:
+            config: Combined configuration to use for initialization
+        """
+        pass
+
+    def validate_inputs(self, **kwargs) -> Dict[str, Any]:
+        """Override to inject runtime parameters before validation."""
+        # Extract connection parameters from runtime inputs
+        connection_params = self._extract_connection_params(kwargs)
+        if connection_params:
+            self.set_runtime_parameters(**connection_params)
+
+        # Initialize if we have new runtime parameters
+        if connection_params and not self._is_initialized:
+            self.initialize_with_runtime_config()
+
+        return super().validate_inputs(**kwargs)
+
+    def _extract_connection_params(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract connection-related parameters from runtime inputs.
+
+        Args:
+            inputs: Runtime input parameters
+
+        Returns:
+            Dictionary of connection parameters
+        """
+        # Define connection parameter patterns
+        connection_param_patterns = [
+            "host",
+            "port",
+            "database",
+            "user",
+            "password",
+            "connection_string",
+            "token_url",
+            "client_id",
+            "client_secret",
+            "auth_url",
+            "api_key",
+            "database_type",
+            "grant_type",
+            "scope",
+            "username",
+        ]
+
+        connection_params = {}
+        for key, value in inputs.items():
+            if key in connection_param_patterns:
+                connection_params[key] = value
+
+        return connection_params
+
+
+class ConfigurableOAuth2Node:
+    """OAuth2Node with runtime parameter injection support.
+
+    This class extends OAuth2Node to support runtime configuration of
+    connection parameters through workflow parameter injection.
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize with deferred OAuth configuration."""
+        from kailash.nodes.base import Node, NodeMetadata
+
+        # Store configuration
+        self._deferred_config = kwargs.copy()
+        self._runtime_config = {}
+        self._is_initialized = False
+        self._oauth_node = None
+
+        # Initialize metadata
+        if "metadata" not in kwargs:
+            kwargs["metadata"] = NodeMetadata(
+                id=kwargs.get("name", "configurable_oauth2").replace(" ", "_").lower(),
+                name=kwargs.get("name", "ConfigurableOAuth2Node"),
+                description="OAuth2 node with runtime parameter injection",
+                tags={"auth", "oauth2", "configurable"},
+                version="1.0.0",
+            )
+
+        # Store metadata for later use
+        self.metadata = kwargs["metadata"]
+
+    def _perform_initialization(self, config: Dict[str, Any]) -> None:
+        """Initialize OAuth2Node with runtime configuration."""
+        from kailash.nodes.api.auth import OAuth2Node
+
+        # Filter out non-OAuth parameters
+        oauth_config = {}
+        oauth_params = [
+            "token_url",
+            "client_id",
+            "client_secret",
+            "grant_type",
+            "scope",
+            "username",
+            "password",
+            "refresh_token",
+        ]
+
+        for param in oauth_params:
+            if param in config:
+                oauth_config[param] = config[param]
+
+        # Create the actual OAuth2Node
+        self._oauth_node = OAuth2Node(**oauth_config)
+        logger.info(
+            f"Initialized OAuth2Node with runtime config: {list(oauth_config.keys())}"
+        )
+
+    def get_parameters(self):
+        """Get parameters from the underlying OAuth2Node or default set."""
+        if self._oauth_node:
+            return self._oauth_node.get_parameters()
+        else:
+            # Return default OAuth2 parameters for workflow building
+            from kailash.nodes.base import NodeParameter
+
+            return {
+                "token_url": NodeParameter(
+                    name="token_url",
+                    type=str,
+                    required=True,
+                    description="OAuth token endpoint URL",
+                ),
+                "client_id": NodeParameter(
+                    name="client_id",
+                    type=str,
+                    required=True,
+                    description="OAuth client ID",
+                ),
+                "client_secret": NodeParameter(
+                    name="client_secret",
+                    type=str,
+                    required=False,
+                    description="OAuth client secret",
+                ),
+                "grant_type": NodeParameter(
+                    name="grant_type",
+                    type=str,
+                    required=False,
+                    default="client_credentials",
+                    description="OAuth grant type",
+                ),
+            }
+
+    def run(self, **kwargs):
+        """Execute OAuth2 authentication with runtime configuration."""
+        # Ensure initialization with current parameters
+        if not self._is_initialized:
+            self.set_runtime_parameters(**kwargs)
+            self.initialize_with_runtime_config()
+
+        if not self._oauth_node:
+            raise RuntimeError(
+                "OAuth2Node not initialized - missing connection parameters"
+            )
+
+        # Delegate to the initialized OAuth2Node
+        return self._oauth_node.execute(**kwargs)
+
+
+class ConfigurableAsyncSQLNode(ParameterInjectionMixin):
+    """AsyncSQLDatabaseNode with runtime parameter injection support.
+
+    This class extends AsyncSQLDatabaseNode to support runtime configuration
+    of database connection parameters through workflow parameter injection.
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize with deferred database configuration."""
+        from kailash.nodes.data.async_sql import AsyncSQLDatabaseNode
+
+        # Don't initialize AsyncSQLDatabaseNode yet - defer until runtime
+        self._sql_node = None
+        super().__init__(**kwargs)
+
+    def _perform_initialization(self, config: Dict[str, Any]) -> None:
+        """Initialize AsyncSQLDatabaseNode with runtime configuration."""
+        from kailash.nodes.data.async_sql import AsyncSQLDatabaseNode
+
+        # Filter out non-SQL parameters
+        sql_config = {}
+        sql_params = [
+            "database_type",
+            "connection_string",
+            "host",
+            "port",
+            "database",
+            "user",
+            "password",
+            "pool_size",
+            "max_pool_size",
+            "timeout",
+        ]
+
+        for param in sql_params:
+            if param in config:
+                sql_config[param] = config[param]
+
+        # Add any query parameters
+        if "query" in config:
+            sql_config["query"] = config["query"]
+        if "params" in config:
+            sql_config["params"] = config["params"]
+        if "fetch_mode" in config:
+            sql_config["fetch_mode"] = config["fetch_mode"]
+
+        # Create the actual AsyncSQLDatabaseNode
+        self._sql_node = AsyncSQLDatabaseNode(**sql_config)
+        logger.info(
+            f"Initialized AsyncSQLDatabaseNode with runtime config: {list(sql_config.keys())}"
+        )
+
+    def get_parameters(self):
+        """Get parameters from the underlying AsyncSQLDatabaseNode or default set."""
+        if self._sql_node:
+            return self._sql_node.get_parameters()
+        else:
+            # Return default SQL parameters for workflow building
+            from kailash.nodes.base import NodeParameter
+
+            return {
+                "database_type": NodeParameter(
+                    name="database_type",
+                    type=str,
+                    required=True,
+                    default="postgresql",
+                    description="Type of database",
+                ),
+                "host": NodeParameter(
+                    name="host", type=str, required=False, description="Database host"
+                ),
+                "database": NodeParameter(
+                    name="database",
+                    type=str,
+                    required=False,
+                    description="Database name",
+                ),
+                "user": NodeParameter(
+                    name="user", type=str, required=False, description="Database user"
+                ),
+                "password": NodeParameter(
+                    name="password",
+                    type=str,
+                    required=False,
+                    description="Database password",
+                ),
+                "query": NodeParameter(
+                    name="query",
+                    type=str,
+                    required=True,
+                    description="SQL query to execute",
+                ),
+            }
+
+    async def async_run(self, **kwargs):
+        """Execute SQL query with runtime configuration."""
+        # Ensure initialization with current parameters
+        if not self._is_initialized:
+            self.set_runtime_parameters(**kwargs)
+            self.initialize_with_runtime_config()
+
+        if not self._sql_node:
+            raise RuntimeError(
+                "AsyncSQLDatabaseNode not initialized - missing connection parameters"
+            )
+
+        # Delegate to the initialized AsyncSQLDatabaseNode
+        return await self._sql_node.async_run(**kwargs)
+
+    def run(self, **kwargs):
+        """Synchronous wrapper for async_run."""
+        import asyncio
+
+        return asyncio.run(self.async_run(**kwargs))
+
+
+class EnterpriseNodeFactory:
+    """Factory for creating enterprise nodes with parameter injection support."""
+
+    @staticmethod
+    def create_oauth2_node(**kwargs) -> ConfigurableOAuth2Node:
+        """Create an OAuth2Node with runtime parameter injection support.
+
+        Args:
+            **kwargs: Initial configuration parameters
+
+        Returns:
+            ConfigurableOAuth2Node instance
+        """
+        return ConfigurableOAuth2Node(**kwargs)
+
+    @staticmethod
+    def create_async_sql_node(**kwargs) -> ConfigurableAsyncSQLNode:
+        """Create an AsyncSQLDatabaseNode with runtime parameter injection support.
+
+        Args:
+            **kwargs: Initial configuration parameters
+
+        Returns:
+            ConfigurableAsyncSQLNode instance
+        """
+        return ConfigurableAsyncSQLNode(**kwargs)
+
+    @staticmethod
+    def wrap_enterprise_node(node_class, **kwargs):
+        """Wrap any enterprise node class with parameter injection support.
+
+        Args:
+            node_class: The enterprise node class to wrap
+            **kwargs: Initial configuration parameters
+
+        Returns:
+            Wrapped node instance with parameter injection support
+        """
+
+        # Create a dynamic wrapper class
+        class WrappedEnterpriseNode(ParameterInjectionMixin):
+            def __init__(self, **init_kwargs):
+                self._wrapped_node = None
+                self._node_class = node_class
+                super().__init__(**init_kwargs)
+
+            def _perform_initialization(self, config):
+                self._wrapped_node = self._node_class(**config)
+
+            def get_parameters(self):
+                if self._wrapped_node:
+                    return self._wrapped_node.get_parameters()
+                else:
+                    # Try to get parameters from class if possible
+                    try:
+                        temp_node = self._node_class()
+                        return temp_node.get_parameters()
+                    except:
+                        return {}
+
+            def run(self, **run_kwargs):
+                if not self._is_initialized:
+                    self.set_runtime_parameters(**run_kwargs)
+                    self.initialize_with_runtime_config()
+
+                if not self._wrapped_node:
+                    raise RuntimeError(f"{self._node_class.__name__} not initialized")
+
+                return self._wrapped_node.execute(**run_kwargs)
+
+        return WrappedEnterpriseNode(**kwargs)
+
+
+# Convenience functions for workflow builders
+def create_configurable_oauth2(**kwargs) -> ConfigurableOAuth2Node:
+    """Convenience function to create a configurable OAuth2 node."""
+    return EnterpriseNodeFactory.create_oauth2_node(**kwargs)
+
+
+def create_configurable_sql(**kwargs) -> ConfigurableAsyncSQLNode:
+    """Convenience function to create a configurable SQL node."""
+    return EnterpriseNodeFactory.create_async_sql_node(**kwargs)