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

kailash/nodes/validation/validation_nodes.py

@@ -0,0 +1,447 @@
+"""Validation nodes for test-driven development.
+
+This module provides specialized nodes for validating code, workflows, and
+running test suites as part of the IterativeLLMAgent's test-driven convergence.
+"""
+
+from typing import Any
+
+from kailash.nodes.base import Node, NodeParameter, register_node
+
+from .test_executor import ValidationLevel, ValidationTestExecutor
+
+
+@register_node()
+class CodeValidationNode(Node):
+    """Validate generated code through multiple levels of testing.
+
+    This node performs comprehensive validation of Python code including:
+    - Syntax validation
+    - Import resolution
+    - Safe execution testing
+    - Output schema validation
+
+    Examples:
+        >>> validator = CodeValidationNode()
+        >>> result = validator.execute(
+        ...     code="def process(x): return {'result': x * 2}",
+        ...     validation_levels=["syntax", "semantic"],
+        ...     test_inputs={"x": 5}
+        ... )
+    """
+
+    def get_parameters(self) -> dict[str, NodeParameter]:
+        """Get node parameters."""
+        return {
+            "code": NodeParameter(
+                name="code",
+                type=str,
+                required=True,
+                description="Python code to validate",
+            ),
+            "validation_levels": NodeParameter(
+                name="validation_levels",
+                type=list,
+                required=False,
+                default=["syntax", "imports", "semantic"],
+                description="Validation levels to run (syntax, imports, semantic, functional)",
+            ),
+            "test_inputs": NodeParameter(
+                name="test_inputs",
+                type=dict,
+                required=False,
+                default={},
+                description="Input data for semantic validation",
+            ),
+            "expected_schema": NodeParameter(
+                name="expected_schema",
+                type=dict,
+                required=False,
+                description="Expected output schema for functional validation",
+            ),
+            "timeout": NodeParameter(
+                name="timeout",
+                type=int,
+                required=False,
+                default=30,
+                description="Maximum execution time in seconds",
+            ),
+            "sandbox": NodeParameter(
+                name="sandbox",
+                type=bool,
+                required=False,
+                default=True,
+                description="Use sandboxed execution for safety",
+            ),
+        }
+
+    def run(self, **kwargs) -> dict[str, Any]:
+        """Execute validation tests on provided code."""
+        code = kwargs["code"]
+        levels = kwargs.get("validation_levels", ["syntax", "imports", "semantic"])
+        test_inputs = kwargs.get("test_inputs", {})
+        expected_schema = kwargs.get("expected_schema")
+        timeout = kwargs.get("timeout", 30)
+        sandbox = kwargs.get("sandbox", True)
+
+        executor = ValidationTestExecutor(sandbox_enabled=sandbox, timeout=timeout)
+        validation_results = []
+
+        # Run requested validation levels
+        if "syntax" in levels:
+            result = executor.validate_python_syntax(code)
+            validation_results.append(result)
+
+            # Stop early if syntax fails
+            if not result.passed:
+                return self._format_results(validation_results, code)
+
+        if "imports" in levels:
+            result = executor.validate_imports(code)
+            validation_results.append(result)
+
+            # Warn but continue if imports fail
+            if not result.passed:
+                self.logger.warning(f"Import validation failed: {result.error}")
+
+        if "semantic" in levels:
+            result = executor.execute_code_safely(code, test_inputs)
+            validation_results.append(result)
+
+            # If semantic validation passed and we have schema, validate output
+            if result.passed and expected_schema and "functional" in levels:
+                # Extract output from execution
+                namespace = {**test_inputs}
+                try:
+                    exec(code, namespace)
+                    output = {
+                        k: v
+                        for k, v in namespace.items()
+                        if k not in test_inputs and not k.startswith("_")
+                    }
+
+                    schema_result = executor.validate_output_schema(
+                        output, expected_schema
+                    )
+                    validation_results.append(schema_result)
+                except Exception as e:
+                    self.logger.error(f"Failed to validate output schema: {e}")
+
+        return self._format_results(validation_results, code)
+
+    def _format_results(self, results: list, code: str) -> dict[str, Any]:
+        """Format validation results for output."""
+        all_passed = all(r.passed for r in results)
+
+        return {
+            "validated": all_passed,
+            "validation_results": [
+                {
+                    "level": r.level.value,
+                    "passed": r.passed,
+                    "test_name": r.test_name,
+                    "details": r.details,
+                    "error": r.error,
+                    "suggestions": r.suggestions,
+                    "execution_time": r.execution_time,
+                }
+                for r in results
+            ],
+            "summary": {
+                "total_tests": len(results),
+                "passed": sum(1 for r in results if r.passed),
+                "failed": sum(1 for r in results if not r.passed),
+                "code_lines": len(code.splitlines()),
+                "total_execution_time": sum(r.execution_time for r in results),
+            },
+            "validation_status": "PASSED" if all_passed else "FAILED",
+        }
+
+
+@register_node()
+class WorkflowValidationNode(Node):
+    """Validate entire workflow definitions and execution.
+
+    This node validates workflow code by:
+    - Parsing workflow definition
+    - Checking node configurations
+    - Validating connections
+    - Optionally executing with test data
+
+    Examples:
+        >>> validator = WorkflowValidationNode()
+        >>> result = validator.execute(
+        ...     workflow_code='''
+        ...     workflow = WorkflowBuilder()
+        ...     workflow.add_node("CSVReaderNode", "reader", {"file_path": "data.csv"})
+        ...     workflow.add_node("PythonCodeNode", "processor", {"code": "..."})
+        ...     workflow.connect("reader", "processor", {"data": "data"})
+        ...     ''',
+        ...     validate_execution=True
+        ... )
+    """
+
+    def get_parameters(self) -> dict[str, NodeParameter]:
+        """Get node parameters."""
+        return {
+            "workflow_code": NodeParameter(
+                name="workflow_code",
+                type=str,
+                required=True,
+                description="Workflow definition code to validate",
+            ),
+            "validate_execution": NodeParameter(
+                name="validate_execution",
+                type=bool,
+                required=False,
+                default=False,
+                description="Whether to execute workflow with test data",
+            ),
+            "test_parameters": NodeParameter(
+                name="test_parameters",
+                type=dict,
+                required=False,
+                default={},
+                description="Parameters for test execution",
+            ),
+            "expected_nodes": NodeParameter(
+                name="expected_nodes",
+                type=list,
+                required=False,
+                description="List of node IDs that should be present",
+            ),
+            "required_connections": NodeParameter(
+                name="required_connections",
+                type=list,
+                required=False,
+                description="List of required connections between nodes",
+            ),
+        }
+
+    def run(self, **kwargs) -> dict[str, Any]:
+        """Validate workflow definition and optionally execute."""
+        workflow_code = kwargs["workflow_code"]
+        validate_execution = kwargs.get("validate_execution", False)
+        test_parameters = kwargs.get("test_parameters", {})
+        expected_nodes = kwargs.get("expected_nodes", [])
+        required_connections = kwargs.get("required_connections", [])
+
+        validation_results = {
+            "syntax_valid": False,
+            "structure_valid": False,
+            "errors": [],
+            "warnings": [],
+        }
+
+        # Only add execution_valid if we're going to validate execution
+        if validate_execution:
+            validation_results["execution_valid"] = False
+
+        # First validate syntax
+        executor = ValidationTestExecutor()
+        syntax_result = executor.validate_python_syntax(workflow_code)
+        validation_results["syntax_valid"] = syntax_result.passed
+
+        if not syntax_result.passed:
+            validation_results["errors"].append(f"Syntax error: {syntax_result.error}")
+            return self._format_workflow_results(validation_results)
+
+        # Try to extract workflow structure
+        try:
+            # Create namespace for execution
+            workflow_builder_class = self._get_workflow_builder_class()
+            namespace = {
+                "WorkflowBuilder": workflow_builder_class,
+                "__builtins__": __builtins__,
+            }
+
+            # Execute workflow code
+            exec(workflow_code, namespace)
+
+            # Find workflow instance
+            workflow = None
+            for var_name, var_value in namespace.items():
+                if hasattr(var_value, "build") and hasattr(var_value, "add_node"):
+                    # Skip the WorkflowBuilder class itself, look for instances
+                    if var_name != "WorkflowBuilder":
+                        workflow = var_value
+                        break
+
+            if not workflow:
+                validation_results["errors"].append("No WorkflowBuilder instance found")
+                return self._format_workflow_results(validation_results)
+
+            # Validate structure
+            built_workflow = workflow.build()
+
+            # Handle both dict format (for testing) and Workflow object (real usage)
+            if hasattr(built_workflow, "nodes"):
+                # Real Workflow object
+                actual_nodes = list(built_workflow.nodes.keys())
+                actual_connections = built_workflow.connections
+            else:
+                # Dict format (for testing)
+                actual_nodes = list(built_workflow["nodes"].keys())
+                actual_connections = built_workflow.get("connections", [])
+
+            # Check expected nodes
+            for expected_node in expected_nodes:
+                if expected_node not in actual_nodes:
+                    validation_results["errors"].append(
+                        f"Missing expected node: {expected_node}"
+                    )
+
+            # Check connections
+            for req_conn in required_connections:
+                found = False
+                for conn in actual_connections:
+                    # Handle both dict format and Connection object
+                    if hasattr(conn, "source_node"):
+                        # Real Connection object
+                        from_node = conn.source_node
+                        to_node = conn.target_node
+                    else:
+                        # Dict format
+                        from_node = conn.get("from_node")
+                        to_node = conn.get("to_node")
+
+                    if from_node == req_conn.get("from") and to_node == req_conn.get(
+                        "to"
+                    ):
+                        found = True
+                        break
+                if not found:
+                    validation_results["errors"].append(
+                        f"Missing connection: {req_conn.get('from')} -> {req_conn.get('to')}"
+                    )
+
+            validation_results["structure_valid"] = (
+                len(validation_results["errors"]) == 0
+            )
+            validation_results["node_count"] = len(actual_nodes)
+            validation_results["connection_count"] = len(actual_connections)
+            validation_results["nodes"] = actual_nodes
+
+            # Optionally execute workflow
+            if validate_execution and validation_results["structure_valid"]:
+                try:
+                    from kailash.runtime.local import LocalRuntime
+
+                    runtime = LocalRuntime()
+
+                    # Execute with test parameters
+                    results, run_id = runtime.execute(
+                        built_workflow, parameters=test_parameters
+                    )
+
+                    # Check for errors
+                    execution_errors = []
+                    for node_id, node_result in results.items():
+                        if isinstance(node_result, dict) and "error" in node_result:
+                            execution_errors.append(
+                                f"Node {node_id}: {node_result['error']}"
+                            )
+
+                    validation_results["execution_valid"] = len(execution_errors) == 0
+                    validation_results["execution_errors"] = execution_errors
+                    validation_results["run_id"] = run_id
+
+                except Exception as e:
+                    validation_results["execution_valid"] = False
+                    validation_results["errors"].append(f"Execution failed: {str(e)}")
+
+        except Exception as e:
+            validation_results["errors"].append(f"Workflow parsing failed: {str(e)}")
+
+        return self._format_workflow_results(validation_results)
+
+    def _get_workflow_builder_class(self):
+        """Get WorkflowBuilder class. Can be overridden for testing."""
+        from kailash.workflow.builder import WorkflowBuilder
+
+        return WorkflowBuilder
+
+    def _format_workflow_results(self, results: dict[str, Any]) -> dict[str, Any]:
+        """Format workflow validation results."""
+        all_valid = (
+            results["syntax_valid"]
+            and results["structure_valid"]
+            and (results["execution_valid"] if "execution_valid" in results else True)
+        )
+
+        return {
+            "validated": all_valid,
+            "workflow_valid": all_valid,
+            "validation_details": results,
+            "validation_status": "PASSED" if all_valid else "FAILED",
+            "error_count": len(results.get("errors", [])),
+            "warning_count": len(results.get("warnings", [])),
+        }
+
+
+@register_node()
+class ValidationTestSuiteExecutorNode(Node):
+    """Execute a test suite against generated code.
+
+    This node runs multiple test cases against code to ensure
+    comprehensive validation.
+
+    Examples:
+        >>> executor = TestSuiteExecutorNode()
+        >>> result = executor.execute(
+        ...     code="def double(x): return {'result': x * 2}",
+        ...     test_suite=[
+        ...         {
+        ...             "name": "test_positive",
+        ...             "inputs": {"x": 5},
+        ...             "expected_output": {"result": 10}
+        ...         },
+        ...         {
+        ...             "name": "test_negative",
+        ...             "inputs": {"x": -3},
+        ...             "expected_output": {"result": -6}
+        ...         }
+        ...     ]
+        ... )
+    """
+
+    def get_parameters(self) -> dict[str, NodeParameter]:
+        """Get node parameters."""
+        return {
+            "code": NodeParameter(
+                name="code", type=str, required=True, description="Code to test"
+            ),
+            "test_suite": NodeParameter(
+                name="test_suite",
+                type=list,
+                required=True,
+                description="List of test cases with inputs and expected outputs",
+            ),
+            "stop_on_failure": NodeParameter(
+                name="stop_on_failure",
+                type=bool,
+                required=False,
+                default=False,
+                description="Stop execution after first test failure",
+            ),
+        }
+
+    def run(self, **kwargs) -> dict[str, Any]:
+        """Execute test suite against code."""
+        code = kwargs["code"]
+        test_suite = kwargs["test_suite"]
+        kwargs.get("stop_on_failure", False)
+
+        executor = ValidationTestExecutor()
+        result = executor.run_test_suite(code, test_suite)
+
+        return {
+            "all_tests_passed": result.passed,
+            "test_results": result.details["results"],
+            "summary": {
+                "total": result.details["total_tests"],
+                "passed": result.details["passed"],
+                "failed": result.details["failed"],
+            },
+            "validation_status": "PASSED" if result.passed else "FAILED",
+        }

kailash/resources/factory.py

@@ -390,7 +390,7 @@ class CacheFactory(ResourceFactory):
             async def get(self, key: str) -> Any:
                 return self._cache.get(key)
 
-            async def set(self, key: str, value: Any, expire: int = None) -> None:
+            async def set(self, key: str, value: Any, ttl: int = None) -> None:
                 self._cache[key] = value
                 # TODO: Implement expiration
 

kailash/runtime/async_local.py

@@ -579,13 +579,65 @@ class AsyncLocalRuntime(LocalRuntime):
         context_inputs: Dict[str, Any],
     ) -> Dict[str, Any]:
         """Prepare inputs for sync node execution."""
-        # Simplified input preparation
         inputs = context_inputs.copy()
 
-        # Add outputs from predecessor nodes
+        # Add outputs from predecessor nodes using proper connection mapping
         for predecessor in workflow.graph.predecessors(node_id):
             if predecessor in node_outputs:
-                inputs[f"{predecessor}_output"] = node_outputs[predecessor]
+                # Use the actual connection mapping if available
+                edge_data = workflow.graph.get_edge_data(predecessor, node_id)
+                if edge_data and "mapping" in edge_data:
+                    # Handle new graph format with mapping
+                    mapping = edge_data["mapping"]
+                    source_data = node_outputs[predecessor]
+
+                    for source_path, target_param in mapping.items():
+                        if source_path == "result":
+                            # Source path is 'result' - use the entire source data
+                            inputs[target_param] = source_data
+                        elif "." in source_path and isinstance(source_data, dict):
+                            # Navigate dotted path (e.g., "result.data" or "nested.field")
+                            path_parts = source_path.split(".")
+
+                            # Special case: if path starts with "result." and source_data doesn't have "result" key,
+                            # try stripping "result." since AsyncPythonCodeNode returns direct dict
+                            if (
+                                path_parts[0] == "result"
+                                and "result" not in source_data
+                                and len(path_parts) > 1
+                            ):
+                                # Try the remaining path without "result"
+                                remaining_path = ".".join(path_parts[1:])
+                                if remaining_path in source_data:
+                                    inputs[target_param] = source_data[remaining_path]
+                                    continue
+                                else:
+                                    # Try navigating remaining path parts
+                                    path_parts = path_parts[1:]
+
+                            current_data = source_data
+                            # Navigate through each part of the path
+                            for part in path_parts:
+                                if (
+                                    isinstance(current_data, dict)
+                                    and part in current_data
+                                ):
+                                    current_data = current_data[part]
+                                else:
+                                    current_data = None
+                                    break
+                            inputs[target_param] = current_data
+                        elif (
+                            isinstance(source_data, dict) and source_path in source_data
+                        ):
+                            # Direct key access
+                            inputs[target_param] = source_data[source_path]
+                        else:
+                            # Fallback - use source data directly
+                            inputs[target_param] = source_data
+                else:
+                    # Fallback to legacy behavior if no mapping
+                    inputs[f"{predecessor}_output"] = node_outputs[predecessor]
 
         return inputs
 
@@ -713,17 +765,31 @@ class AsyncLocalRuntime(LocalRuntime):
                     source_data = tracker.node_outputs[predecessor]
 
                     for source_path, target_param in mapping.items():
-                        if source_path != "result" and isinstance(source_data, dict):
-                            # Navigate the path (e.g., "result.data")
+                        if source_path == "result":
+                            # Source path is 'result' - use the entire source data
+                            inputs[target_param] = source_data
+                        elif "." in source_path and isinstance(source_data, dict):
+                            # Navigate dotted path (e.g., "result.data" or "nested.field")
                             path_parts = source_path.split(".")
-                            current_data = source_data
 
-                            # CRITICAL FIX: Handle paths starting with "result"
-                            # When source_path is "result.field", the node output IS the result
-                            if path_parts[0] == "result" and len(path_parts) > 1:
-                                # Skip the "result" prefix and navigate from the actual data
-                                path_parts = path_parts[1:]
+                            # Special case: if path starts with "result." and source_data doesn't have "result" key,
+                            # try stripping "result." since AsyncPythonCodeNode returns direct dict
+                            if (
+                                path_parts[0] == "result"
+                                and "result" not in source_data
+                                and len(path_parts) > 1
+                            ):
+                                # Try the remaining path without "result"
+                                remaining_path = ".".join(path_parts[1:])
+                                if remaining_path in source_data:
+                                    inputs[target_param] = source_data[remaining_path]
+                                    continue
+                                else:
+                                    # Try navigating remaining path parts
+                                    path_parts = path_parts[1:]
 
+                            current_data = source_data
+                            # Navigate through each part of the path
                             for part in path_parts:
                                 if (
                                     isinstance(current_data, dict)
@@ -734,17 +800,14 @@ class AsyncLocalRuntime(LocalRuntime):
                                     current_data = None
                                     break
                             inputs[target_param] = current_data
+                        elif (
+                            isinstance(source_data, dict) and source_path in source_data
+                        ):
+                            # Direct key access
+                            inputs[target_param] = source_data[source_path]
                         else:
-                            # Source path is 'result' or source_data is not a dict
-                            if source_path == "result":
-                                inputs[target_param] = source_data
-                            elif (
-                                isinstance(source_data, dict)
-                                and source_path in source_data
-                            ):
-                                inputs[target_param] = source_data[source_path]
-                            else:
-                                inputs[target_param] = source_data
+                            # Fallback - use source data directly
+                            inputs[target_param] = source_data
                 elif edge_data and "connections" in edge_data:
                     # Handle legacy connection format
                     connections = edge_data["connections"]

kailash/runtime/local.py

@@ -567,12 +567,19 @@ class LocalRuntime:
                 collector = MetricsCollector()
                 with collector.collect(node_id=node_id) as metrics_context:
                     # Unified async/sync execution
+                    # Validate inputs before execution
+                    from kailash.utils.data_validation import DataTypeValidator
+
+                    validated_inputs = DataTypeValidator.validate_node_input(
+                        node_id, inputs
+                    )
+
                     if self.enable_async and hasattr(node_instance, "execute_async"):
                         # Use async execution method that includes validation
-                        outputs = await node_instance.execute_async(**inputs)
+                        outputs = await node_instance.execute_async(**validated_inputs)
                     else:
                         # Standard synchronous execution
-                        outputs = node_instance.execute(**inputs)
+                        outputs = node_instance.execute(**validated_inputs)
 
                 # Get performance metrics
                 performance_metrics = metrics_context.result()
@@ -698,6 +705,18 @@ class LocalRuntime:
                         f"Cannot use outputs from failed node '{source_node_id}'"
                     )
 
+                # Validate source outputs before mapping
+                from kailash.utils.data_validation import DataTypeValidator
+
+                try:
+                    source_outputs = DataTypeValidator.validate_node_output(
+                        source_node_id, source_outputs
+                    )
+                except Exception as e:
+                    self.logger.warning(
+                        f"Data validation failed for node '{source_node_id}': {e}"
+                    )
+
                 for source_key, target_key in mapping.items():
                     # Handle nested output access (e.g., "result.files")
                     if "." in source_key: