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

kailash/nodes/rag/strategies.py

@@ -412,7 +412,7 @@ class SemanticRAGNode(Node):
             self.workflow_node = create_semantic_rag_workflow(self.config)
 
         # Delegate to WorkflowNode
-        return self.workflow_node.run(**kwargs)
+        return self.workflow_node.execute(**kwargs)
 
 
 @register_node()
@@ -458,7 +458,7 @@ class StatisticalRAGNode(Node):
         if not self.workflow_node:
             self.workflow_node = create_statistical_rag_workflow(self.config)
 
-        return self.workflow_node.run(**kwargs)
+        return self.workflow_node.execute(**kwargs)
 
 
 @register_node()
@@ -517,7 +517,7 @@ class HybridRAGNode(Node):
             self.fusion_method = fusion_method
             self.workflow_node = create_hybrid_rag_workflow(self.config, fusion_method)
 
-        return self.workflow_node.run(**kwargs)
+        return self.workflow_node.execute(**kwargs)
 
 
 @register_node()
@@ -563,4 +563,4 @@ class HierarchicalRAGNode(Node):
         if not self.workflow_node:
             self.workflow_node = create_hierarchical_rag_workflow(self.config)
 
-        return self.workflow_node.run(**kwargs)
+        return self.workflow_node.execute(**kwargs)

kailash/nodes/security/abac_evaluator.py

@@ -194,7 +194,7 @@ class ABACPermissionEvaluatorNode(SecurityMixin, PerformanceMixin, LoggingMixin,
         ...     "network": "corporate"
         ... }
         >>>
-        >>> result = evaluator.run(
+        >>> result = evaluator.execute(
         ...     user_context=user_context,
         ...     resource_context=resource_context,
         ...     environment_context=env_context,
@@ -770,7 +770,7 @@ class ABACPermissionEvaluatorNode(SecurityMixin, PerformanceMixin, LoggingMixin,
 
     async def execute_async(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for test compatibility."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)
 
     def _evaluate_permission(
         self, context: ABACContext, permission: str
@@ -1026,7 +1026,7 @@ class ABACPermissionEvaluatorNode(SecurityMixin, PerformanceMixin, LoggingMixin,
             )
 
             # Run AI analysis
-            ai_response = self.ai_agent.run(
+            ai_response = self.ai_agent.execute(
                 provider="ollama",
                 model=self.ai_model.replace("ollama:", ""),
                 messages=[{"role": "user", "content": prompt}],
@@ -1275,7 +1275,7 @@ Return a JSON object with this structure:
         }
 
         try:
-            self.audit_log_node.run(**audit_entry)
+            self.audit_log_node.execute(**audit_entry)
         except Exception as e:
             self.log_with_context(
                 "WARNING", f"Failed to audit permission decision: {e}"
@@ -1355,7 +1355,7 @@ RESPONSE FORMAT:
 }}
 """
 
-            ai_response = self.ai_agent.run(
+            ai_response = self.ai_agent.execute(
                 provider="ollama",
                 model=self.ai_model.replace("ollama:", ""),
                 messages=[{"role": "user", "content": prompt}],
@@ -1408,4 +1408,4 @@ RESPONSE FORMAT:
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/security/behavior_analysis.py

@@ -107,7 +107,7 @@ class BehaviorAnalysisNode(SecurityMixin, PerformanceMixin, LoggingMixin, Node):
         ...     "data_volume_mb": 15.5
         ... }
         >>>
-        >>> result = behavior_analyzer.run(
+        >>> result = behavior_analyzer.execute(
         ...     action="analyze",
         ...     user_id="user123",
         ...     recent_activity=[activity]
@@ -417,7 +417,7 @@ class BehaviorAnalysisNode(SecurityMixin, PerformanceMixin, LoggingMixin, Node):
             # Create audit log entry
             if result.get("success", False):
                 try:
-                    self.audit_log_node.run(
+                    self.audit_log_node.execute(
                         action="behavior_analysis",
                         user_id=user_id or "unknown",
                         result="success",
@@ -1185,7 +1185,7 @@ RESPONSE FORMAT:
 """
 
             # Run AI analysis
-            ai_response = self.ai_agent.run(
+            ai_response = self.ai_agent.execute(
                 provider="ollama",
                 model=self.ai_model.replace("ollama:", ""),
                 messages=[{"role": "user", "content": prompt}],
@@ -1370,7 +1370,7 @@ RESPONSE FORMAT:
         }
 
         try:
-            self.security_event_node.run(**security_event)
+            self.security_event_node.execute(**security_event)
         except Exception as e:
             self.log_with_context("WARNING", f"Failed to log anomaly event: {e}")
 
@@ -1890,4 +1890,4 @@ RESPONSE FORMAT:
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/security/credential_manager.py

@@ -398,4 +398,4 @@ class CredentialManagerNode(Node):
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/security/rotating_credentials.py

@@ -255,7 +255,7 @@ class RotatingCredentialNode(Node):
         """Check if a credential is approaching expiration."""
         try:
             # Get current credential
-            credential_result = self._credential_manager.run(
+            credential_result = self._credential_manager.execute(
                 operation="get_credential", credential_name=credential_name
             )
 
@@ -314,7 +314,7 @@ class RotatingCredentialNode(Node):
             # Try each refresh source in order
             for source in refresh_sources:
                 try:
-                    refresh_result = self._credential_manager.run(
+                    refresh_result = self._credential_manager.execute(
                         operation="get_credential",
                         credential_name=credential_name,
                         credential_sources=[source],
@@ -363,7 +363,7 @@ class RotatingCredentialNode(Node):
             # Step 1: Get current credential (for rollback if needed)
             current_credential = None
             if rollback_on_failure:
-                current_result = self._credential_manager.run(
+                current_result = self._credential_manager.execute(
                     operation="get_credential", credential_name=credential_name
                 )
                 if current_result.get("success"):
@@ -390,7 +390,7 @@ class RotatingCredentialNode(Node):
             new_credential = refresh_result["credential"]
 
             # Step 3: Validate new credential
-            validation_result = self._credential_manager.run(
+            validation_result = self._credential_manager.execute(
                 operation="validate_credential",
                 credential_name=credential_name,
                 credential_data=new_credential,
@@ -422,7 +422,7 @@ class RotatingCredentialNode(Node):
 
                 temp_credential_name = f"{credential_name}_rotating_{int(time.time())}"
 
-                store_result = self._credential_manager.run(
+                store_result = self._credential_manager.execute(
                     operation="store_credential",
                     credential_name=temp_credential_name,
                     credential_data=new_credential,
@@ -445,7 +445,7 @@ class RotatingCredentialNode(Node):
                 # For this example, we'll assume it passes
 
                 # Atomic switch
-                final_store_result = self._credential_manager.run(
+                final_store_result = self._credential_manager.execute(
                     operation="store_credential",
                     credential_name=credential_name,
                     credential_data=new_credential,
@@ -454,7 +454,7 @@ class RotatingCredentialNode(Node):
                 if not final_store_result.get("success"):
                     # Rollback if requested
                     if rollback_on_failure and current_credential:
-                        self._credential_manager.run(
+                        self._credential_manager.execute(
                             operation="store_credential",
                             credential_name=credential_name,
                             credential_data=current_credential,
@@ -476,13 +476,13 @@ class RotatingCredentialNode(Node):
                     }
 
                 # Clean up temporary credential
-                self._credential_manager.run(
+                self._credential_manager.execute(
                     operation="delete_credential", credential_name=temp_credential_name
                 )
 
             else:
                 # Direct replacement
-                store_result = self._credential_manager.run(
+                store_result = self._credential_manager.execute(
                     operation="store_credential",
                     credential_name=credential_name,
                     credential_data=new_credential,
@@ -491,7 +491,7 @@ class RotatingCredentialNode(Node):
                 if not store_result.get("success"):
                     # Rollback if requested
                     if rollback_on_failure and current_credential:
-                        self._credential_manager.run(
+                        self._credential_manager.execute(
                             operation="store_credential",
                             credential_name=credential_name,
                             credential_data=current_credential,
@@ -757,4 +757,4 @@ class RotatingCredentialNode(Node):
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/security/threat_detection.py

@@ -45,7 +45,7 @@ class ThreatDetectionNode(SecurityMixin, PerformanceMixin, LoggingMixin, Node):
         ...     {"type": "login", "user": "admin", "ip": "192.168.1.100", "failed": True}
         ... ]
         >>>
-        >>> threats = threat_detector.run(events=events)
+        >>> threats = threat_detector.execute(events=events)
         >>> print(f"Detected {len(threats['threats'])} threats")
     """
 
@@ -661,7 +661,7 @@ class ThreatDetectionNode(SecurityMixin, PerformanceMixin, LoggingMixin, Node):
             prompt = self._create_ai_analysis_prompt(event_summary, context)
 
             # Run AI analysis
-            ai_response = self.ai_agent.run(
+            ai_response = self.ai_agent.execute(
                 provider="ollama",
                 model=self.ai_model.replace("ollama:", ""),
                 messages=[{"role": "user", "content": prompt}],
@@ -923,7 +923,7 @@ If no threats are detected, return an empty array: []
             "source_ip": threat.get("source_ip", "unknown"),
         }
 
-        self.security_event_node.run(**alert_event)
+        self.security_event_node.execute(**alert_event)
 
     def _block_ip(self, threat: Dict[str, Any]) -> None:
         """Block IP address associated with threat.
@@ -949,7 +949,7 @@ If no threats are detected, return an empty array: []
                 "source_ip": ip,
             }
 
-            self.security_event_node.run(**block_event)
+            self.security_event_node.execute(**block_event)
 
     def _lock_account(self, threat: Dict[str, Any]) -> None:
         """Lock user account associated with threat.
@@ -974,7 +974,7 @@ If no threats are detected, return an empty array: []
                 "source_ip": threat.get("source_ip", "unknown"),
             }
 
-            self.security_event_node.run(**lock_event)
+            self.security_event_node.execute(**lock_event)
 
     def _quarantine_resource(self, threat: Dict[str, Any]) -> None:
         """Quarantine resource associated with threat.
@@ -996,7 +996,7 @@ If no threats are detected, return an empty array: []
             "source_ip": threat.get("source_ip", "unknown"),
         }
 
-        self.security_event_node.run(**quarantine_event)
+        self.security_event_node.execute(**quarantine_event)
 
     def _log_threat(self, threat: Dict[str, Any]) -> None:
         """Log threat to audit trail.
@@ -1014,7 +1014,7 @@ If no threats are detected, return an empty array: []
             "ip_address": threat.get("source_ip", "unknown"),
         }
 
-        self.audit_log_node.run(**log_entry)
+        self.audit_log_node.execute(**log_entry)
 
     def _update_stats(
         self, events_processed: int, threats_detected: int, processing_time_ms: float
@@ -1100,4 +1100,4 @@ If no threats are detected, return an empty array: []
 
     async def async_run(self, **kwargs) -> Dict[str, Any]:
         """Async execution method for enterprise integration."""
-        return self.run(**kwargs)
+        return self.execute(**kwargs)

kailash/nodes/testing/credential_testing.py

@@ -39,7 +39,7 @@ class CredentialTestingNode(Node):
     Example:
         >>> # Test OAuth2 token expiration
         >>> tester = CredentialTestingNode()
-        >>> result = tester.run(
+        >>> result = tester.execute(
         ...     credential_type='oauth2',
         ...     scenario='expired',
         ...     mock_data={'client_id': 'test_client'}
@@ -48,7 +48,7 @@ class CredentialTestingNode(Node):
         >>> assert 'expired_token' in result['error_details']
         >>>
         >>> # Test successful API key validation
-        >>> result = tester.run(
+        >>> result = tester.execute(
         ...     credential_type='api_key',
         ...     scenario='success',
         ...     validation_rules={'key_length': 32}

kailash/nodes/transform/processors.py

@@ -68,7 +68,7 @@ class FilterNode(Node):
     Examples:
         >>> # Filter list of numbers
         >>> filter_node = FilterNode()
-        >>> result = filter_node.run(
+        >>> result = filter_node.execute(
         ...     data=[1, 2, 3, 4, 5],
         ...     operator=">",
         ...     value=3
@@ -81,7 +81,7 @@ class FilterNode(Node):
         ...     {"name": "Bob", "age": 25},
         ...     {"name": "Charlie", "age": 35}
         ... ]
-        >>> result = filter_node.run(
+        >>> result = filter_node.execute(
         ...     data=users,
         ...     field="age",
         ...     operator=">=",
@@ -96,7 +96,7 @@ class FilterNode(Node):
         ...     {"title": "Java Development"},
         ...     {"title": "Python for Data Science"}
         ... ]
-        >>> result = filter_node.run(
+        >>> result = filter_node.execute(
         ...     data=items,
         ...     field="title",
         ...     operator="contains",
@@ -110,7 +110,7 @@ class FilterNode(Node):
         ...     {"value": None},
         ...     {"value": 20}
         ... ]
-        >>> result = filter_node.run(
+        >>> result = filter_node.execute(
         ...     data=data_with_nulls,
         ...     field="value",
         ...     operator="!=",
@@ -570,7 +570,7 @@ class ContextualCompressorNode(Node):
         ...     compression_ratio=0.6,
         ...     relevance_threshold=0.7
         ... )
-        >>> result = compressor.run(
+        >>> result = compressor.execute(
         ...     query="machine learning algorithms",
         ...     retrieved_docs=[{"content": "...", "metadata": {}}],
         ...     compression_target=1500

kailash/runtime/local.py

@@ -42,6 +42,7 @@ 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 +136,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 +173,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 +198,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 +258,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 +293,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 +308,7 @@ class LocalRuntime:
                     {
                         "workflow_id": workflow.workflow_id,
                         "user_context": self._serialize_user_context(),
-                        "parameters": parameters,
+                        "parameters": processed_parameters,
                     },
                 )
 
@@ -315,7 +321,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 +341,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 +360,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
@@ -544,6 +550,16 @@ class LocalRuntime:
                 {**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}")
 
@@ -961,3 +977,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