kailash 0.8.7__tar.gz → 0.9.1__tar.gz

{kailash-0.8.7/src/kailash.egg-info → kailash-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.8.7
+Version: 0.9.1
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum

{kailash-0.8.7 → kailash-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.8.7"
+version = "0.9.1"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}

{kailash-0.8.7 → kailash-0.9.1}/src/kailash/__init__.py

@@ -3,10 +3,9 @@
 The Kailash SDK provides a comprehensive framework for creating nodes and workflows
 that align with container-node architecture while allowing rapid prototyping.
 
-New in v0.8.7: MCP Parameter Validation Tool, 100% MCP Protocol compliance with missing
-handlers, Phase 2 MCP subscriptions with GraphQL optimization, WebSocket compression, and
-Redis-backed distributed coordination.
-Previous v0.8.6: Enhanced parameter validation system with debugging tools.
+New in v0.9.1: DataFlow PostgreSQL parameter conversion verification and comprehensive testing infrastructure.
+Complete validation of parameter conversion chain from DataFlow to AsyncSQLDatabaseNode to PostgreSQL.
+Previous v0.9.0: Complete migration from cycle=True to modern CycleBuilder API.
 """
 
 from kailash.nodes.base import Node, NodeMetadata, NodeParameter
@@ -49,7 +48,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.8.6"
+__version__ = "0.9.1"
 
 __all__ = [
     # Core workflow components

{kailash-0.8.7 → kailash-0.9.1}/src/kailash/nodes/data/async_sql.py

@@ -493,7 +493,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 and "RETURNING" not in query_upper
                 and fetch_mode == FetchMode.ALL
             ):
-                result = await conn.execute(query, *params)
+                if isinstance(params, dict):
+                    result = await conn.execute(query, params)
+                else:
+                    result = await conn.execute(query, *params)
                 # asyncpg returns a string like "UPDATE 1", extract the count
                 if isinstance(result, str):
                     parts = result.split()
@@ -505,15 +508,24 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 return []
 
             if fetch_mode == FetchMode.ONE:
-                row = await conn.fetchrow(query, *params)
+                if isinstance(params, dict):
+                    row = await conn.fetchrow(query, params)
+                else:
+                    row = await conn.fetchrow(query, *params)
                 return self._convert_row(dict(row)) if row else None
             elif fetch_mode == FetchMode.ALL:
-                rows = await conn.fetch(query, *params)
+                if isinstance(params, dict):
+                    rows = await conn.fetch(query, params)
+                else:
+                    rows = await conn.fetch(query, *params)
                 return [self._convert_row(dict(row)) for row in rows]
             elif fetch_mode == FetchMode.MANY:
                 if not fetch_size:
                     raise ValueError("fetch_size required for MANY mode")
-                rows = await conn.fetch(query, *params)
+                if isinstance(params, dict):
+                    rows = await conn.fetch(query, params)
+                else:
+                    rows = await conn.fetch(query, *params)
                 return [self._convert_row(dict(row)) for row in rows[:fetch_size]]
             elif fetch_mode == FetchMode.ITERATOR:
                 raise NotImplementedError("Iterator mode not yet implemented")
@@ -532,7 +544,10 @@ class PostgreSQLAdapter(DatabaseAdapter):
                     and "RETURNING" not in query_upper
                     and fetch_mode == FetchMode.ALL
                 ):
-                    result = await conn.execute(query, *params)
+                    if isinstance(params, dict):
+                        result = await conn.execute(query, params)
+                    else:
+                        result = await conn.execute(query, *params)
                     # asyncpg returns a string like "UPDATE 1", extract the count
                     if isinstance(result, str):
                         parts = result.split()
@@ -544,15 +559,24 @@ class PostgreSQLAdapter(DatabaseAdapter):
                     return []
 
                 if fetch_mode == FetchMode.ONE:
-                    row = await conn.fetchrow(query, *params)
+                    if isinstance(params, dict):
+                        row = await conn.fetchrow(query, params)
+                    else:
+                        row = await conn.fetchrow(query, *params)
                     return self._convert_row(dict(row)) if row else None
                 elif fetch_mode == FetchMode.ALL:
-                    rows = await conn.fetch(query, *params)
+                    if isinstance(params, dict):
+                        rows = await conn.fetch(query, params)
+                    else:
+                        rows = await conn.fetch(query, *params)
                     return [self._convert_row(dict(row)) for row in rows]
                 elif fetch_mode == FetchMode.MANY:
                     if not fetch_size:
                         raise ValueError("fetch_size required for MANY mode")
-                    rows = await conn.fetch(query, *params)
+                    if isinstance(params, dict):
+                        rows = await conn.fetch(query, params)
+                    else:
+                        rows = await conn.fetch(query, *params)
                     return [self._convert_row(dict(row)) for row in rows[:fetch_size]]
                 elif fetch_mode == FetchMode.ITERATOR:
                     raise NotImplementedError("Iterator mode not yet implemented")

{kailash-0.8.7 → kailash-0.9.1}/src/kailash/nodes/logic/operations.py

@@ -85,10 +85,14 @@ class SwitchNode(Node):
         ...     operator="==",
         ...     value=True
         ... ))
-        >>> workflow.connect("convergence", "switch")
-        >>> workflow.connect("switch", "processor",
-        ...     condition="false_output", cycle=True)
-        >>> workflow.connect("switch", "output", condition="true_output")
+        >>> workflow.add_connection("convergence", "result", "switch", "input_data")
+        >>> # Use CycleBuilder for cyclic connections
+        >>> cycle = workflow.create_cycle("convergence_loop")
+        >>> cycle.connect("switch", "false_output", "processor", "input")
+        >>> cycle.connect("processor", "result", "convergence", "data")
+        >>> cycle.max_iterations(50).build()
+        >>> # Non-cyclic output connection
+        >>> workflow.add_connection("switch", "true_output", "output", "data")
     """
 
     def get_parameters(self) -> dict[str, NodeParameter]:

{kailash-0.8.7 → kailash-0.9.1}/src/kailash/runtime/local.py

@@ -636,6 +636,26 @@ class LocalRuntime:
                 if self.debug:
                     self.logger.debug(f"Node {node_id} inputs: {inputs}")
 
+                # CONDITIONAL EXECUTION: Skip nodes that only receive None inputs from conditional routing
+                if self._should_skip_conditional_node(workflow, node_id, inputs):
+                    self.logger.info(
+                        f"Skipping node {node_id} - all conditional inputs are None"
+                    )
+                    # Store None result to indicate the node was skipped
+                    results[node_id] = None
+                    node_outputs[node_id] = None
+
+                    # Update task status if tracking is enabled
+                    if task and task_manager:
+                        task_manager.update_task_status(
+                            task.task_id,
+                            TaskStatus.COMPLETED,
+                            result=None,
+                            ended_at=datetime.now(UTC),
+                            metadata={"skipped": True, "reason": "conditional_routing"},
+                        )
+                    continue
+
                 # Execute node with unified async/sync support and metrics collection
                 collector = MetricsCollector()
                 with collector.collect(node_id=node_id) as metrics_context:
@@ -1123,6 +1143,88 @@ class LocalRuntime:
         metrics_collector = get_metrics_collector()
         metrics_collector.reset_metrics()
 
+    def _should_skip_conditional_node(
+        self, workflow: Workflow, node_id: str, inputs: dict[str, Any]
+    ) -> bool:
+        """Determine if a node should be skipped due to conditional routing.
+
+        A node should be skipped if:
+        1. It has incoming connections from conditional nodes (like SwitchNode)
+        2. All of its connected inputs are None
+        3. It has no node-level configuration parameters that would make it run independently
+
+        Args:
+            workflow: The workflow being executed.
+            node_id: Node ID to check.
+            inputs: Prepared inputs for the node.
+
+        Returns:
+            True if the node should be skipped, False otherwise.
+        """
+        # Get all incoming edges for this node
+        incoming_edges = list(workflow.graph.in_edges(node_id, data=True))
+
+        # If the node has no incoming connections, don't skip it
+        # (it might be a source node or have configuration parameters)
+        if not incoming_edges:
+            return False
+
+        # Check if any incoming edges are from conditional nodes
+        has_conditional_inputs = False
+        for source_node_id, _, edge_data in incoming_edges:
+            source_node = workflow._node_instances.get(source_node_id)
+            if source_node and source_node.__class__.__name__ in ["SwitchNode"]:
+                has_conditional_inputs = True
+                break
+
+        # If no conditional inputs, don't skip
+        if not has_conditional_inputs:
+            return False
+
+        # Get the node instance to check for configuration parameters
+        node_instance = workflow._node_instances.get(node_id)
+        if not node_instance:
+            return False
+
+        # Check if the node has configuration parameters that would make it run independently
+        # (excluding standard parameters and None values)
+        node_config = getattr(node_instance, "config", {})
+        significant_config = {
+            k: v
+            for k, v in node_config.items()
+            if k not in ["metadata", "name", "id"] and v is not None
+        }
+
+        # If the node has significant configuration, it might still be valuable to run
+        if significant_config:
+            # Check if any connected inputs have actual data (not None)
+            connected_inputs = {}
+            for _, _, edge_data in incoming_edges:
+                mapping = edge_data.get("mapping", {})
+                for source_key, target_key in mapping.items():
+                    if target_key in inputs:
+                        connected_inputs[target_key] = inputs[target_key]
+
+            # If all connected inputs are None but node has config, still skip
+            # The user can configure the node to run with default values if needed
+            if all(v is None for v in connected_inputs.values()):
+                return True
+
+        # Check if all connected inputs are None
+        # This is the main condition for conditional routing
+        has_non_none_input = False
+        for _, _, edge_data in incoming_edges:
+            mapping = edge_data.get("mapping", {})
+            for source_key, target_key in mapping.items():
+                if target_key in inputs and inputs[target_key] is not None:
+                    has_non_none_input = True
+                    break
+            if has_non_none_input:
+                break
+
+        # Skip the node if all connected inputs are None
+        return not has_non_none_input
+
     def _should_stop_on_error(self, workflow: Workflow, node_id: str) -> bool:
         """Determine if execution should stop when a node fails.
 

{kailash-0.8.7 → kailash-0.9.1}/src/kailash/workflow/cyclic_runner.py

@@ -220,6 +220,60 @@ class CyclicWorkflowExecutor:
         else:
             return obj
 
+    def _should_skip_conditional_node_cyclic(
+        self, workflow: Workflow, node_id: str, merged_inputs: dict[str, Any]
+    ) -> bool:
+        """Determine if a node should be skipped due to conditional routing in cyclic execution.
+
+        This is similar to LocalRuntime._should_skip_conditional_node but adapted for cyclic execution.
+
+        Args:
+            workflow: The workflow being executed.
+            node_id: Node ID to check.
+            merged_inputs: Merged inputs for the node.
+
+        Returns:
+            True if the node should be skipped, False otherwise.
+        """
+        # Get all incoming edges for this node
+        incoming_edges = list(workflow.graph.in_edges(node_id, data=True))
+
+        # If the node has no incoming connections, don't skip it
+        if not incoming_edges:
+            return False
+
+        # Check if any incoming edges are from conditional nodes
+        has_conditional_inputs = False
+        for source_node_id, _, edge_data in incoming_edges:
+            try:
+                source_node = workflow.get_node(source_node_id)
+                if source_node and source_node.__class__.__name__ in ["SwitchNode"]:
+                    has_conditional_inputs = True
+                    break
+            except:
+                continue
+
+        # If no conditional inputs, don't skip
+        if not has_conditional_inputs:
+            return False
+
+        # Check if all connected inputs are None
+        has_non_none_input = False
+        for _, _, edge_data in incoming_edges:
+            mapping = edge_data.get("mapping", {})
+            for source_key, target_key in mapping.items():
+                if (
+                    target_key in merged_inputs
+                    and merged_inputs[target_key] is not None
+                ):
+                    has_non_none_input = True
+                    break
+            if has_non_none_input:
+                break
+
+        # Skip the node if all connected inputs are None
+        return not has_non_none_input
+
     def _execute_with_cycles(
         self,
         workflow: Workflow,
@@ -863,6 +917,20 @@ class CyclicWorkflowExecutor:
             except Exception as e:
                 logger.warning(f"Failed to create task for node '{node_id}': {e}")
 
+        # CONDITIONAL EXECUTION: Skip nodes that only receive None inputs from conditional routing
+        if self._should_skip_conditional_node_cyclic(workflow, node_id, merged_inputs):
+            logger.info(f"Skipping node {node_id} - all conditional inputs are None")
+            # Store None result to indicate the node was skipped
+            if task and task_manager:
+                task_manager.update_task_status(
+                    task.task_id,
+                    TaskStatus.COMPLETED,
+                    result=None,
+                    ended_at=datetime.now(UTC),
+                    metadata={"skipped": True, "reason": "conditional_routing"},
+                )
+            return None
+
         # Execute node with metrics collection
         collector = MetricsCollector()
         logger.debug(

{kailash-0.8.7 → kailash-0.9.1/src/kailash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.8.7
+Version: 0.9.1
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum