kailash 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

kailash/nodes/transform/processors.py

@@ -332,12 +332,35 @@ class DataTransformer(Node):
             },  # Support for up to 5 additional arguments
         }
 
+    def validate_inputs(self, **kwargs) -> Dict[str, Any]:
+        """Override validate_inputs to accept arbitrary parameters for transformations.
+
+        DataTransformer needs to accept any input parameters that might be mapped
+        from other nodes, not just the predefined parameters in get_parameters().
+        This enables flexible data flow in workflows.
+        """
+        # First, do the standard validation for defined parameters
+        validated = super().validate_inputs(**kwargs)
+
+        # Then, add any extra parameters that aren't in the schema
+        # These will be passed to the transformation context
+        defined_params = set(self.get_parameters().keys())
+        for key, value in kwargs.items():
+            if key not in defined_params:
+                validated[key] = value  # Accept arbitrary additional parameters
+
+        return validated
+
     def run(self, **kwargs) -> Dict[str, Any]:
         # Extract the transformation functions
         transformations = kwargs.get("transformations", [])
         if not transformations:
             return {"result": kwargs.get("data", [])}
 
+        # Debug: Check what kwargs we received
+        print(f"DATATRANSFORMER RUN DEBUG: kwargs keys = {list(kwargs.keys())}")
+        print(f"DATATRANSFORMER RUN DEBUG: kwargs = {kwargs}")
+
         # Get all input data
         input_data = {}
         for key, value in kwargs.items():
@@ -371,6 +394,14 @@ class DataTransformer(Node):
                     local_vars = input_data.copy()
                     local_vars["result"] = result
 
+                    # Debug: Print available variables
+                    print(
+                        f"DataTransformer DEBUG - Available variables: {list(local_vars.keys())}"
+                    )
+                    print(
+                        f"DataTransformer DEBUG - Input data keys: {list(input_data.keys())}"
+                    )
+
                     # Execute the code block
                     exec(transform_str, safe_globals, local_vars)  # noqa: S102
 

kailash/runtime/local.py

@@ -399,8 +399,13 @@ class LocalRuntime:
             source_node_id = edge[0]
             mapping = edge[2].get("mapping", {})
 
+            print(f"LOCAL RUNTIME DEBUG: Processing edge {source_node_id} -> {node_id}")
+            print(f"  Edge data: {edge[2]}")
+            print(f"  Mapping: {mapping}")
+
             if source_node_id in node_outputs:
                 source_outputs = node_outputs[source_node_id]
+                print(f"  Source outputs: {list(source_outputs.keys())}")
 
                 # Check if the source node failed
                 if isinstance(source_outputs, dict) and source_outputs.get("failed"):
@@ -411,11 +416,19 @@ class LocalRuntime:
                 for source_key, target_key in mapping.items():
                     if source_key in source_outputs:
                         inputs[target_key] = source_outputs[source_key]
+                        print(
+                            f"  MAPPED: {source_key} -> {target_key} (type: {type(source_outputs[source_key])})"
+                        )
                     else:
+                        print(
+                            f"  MISSING: {source_key} not in {list(source_outputs.keys())}"
+                        )
                         self.logger.warning(
                             f"Source output '{source_key}' not found in node '{source_node_id}'. "
                             f"Available outputs: {list(source_outputs.keys())}"
                         )
+            else:
+                print(f"  No outputs found for source node {source_node_id}")
 
         # Apply parameter overrides
         inputs.update(parameters)

kailash/workflow/convergence.py

@@ -229,7 +229,7 @@ class AdaptiveCondition(ConvergenceCondition):
 
 
 def create_convergence_condition(
-    spec: Union[str, int, Callable, Dict]
+    spec: Union[str, int, Callable, Dict],
 ) -> ConvergenceCondition:
     """Factory function to create convergence conditions from various specs.