kailash 0.9.1__py3-none-any.whl → 0.9.3__py3-none-any.whl

kailash/workflow/cyclic_runner.py

@@ -408,21 +408,32 @@ class CyclicWorkflowExecutor:
         """
         results = {}
 
+        # Track nodes that need execution after cycles
+        pending_post_cycle_nodes = set()
+
         logger.info(f"Executing plan with {len(plan.stages)} stages")
 
         for i, stage in enumerate(plan.stages):
+            stage_nodes = getattr(stage, "nodes", "N/A")
             logger.info(
-                f"Executing stage {i+1}: is_cycle={stage.is_cycle}, nodes={getattr(stage, 'nodes', 'N/A')}"
+                f"Executing stage {i+1}: is_cycle={stage.is_cycle}, nodes={stage_nodes}"
             )
             if stage.is_cycle:
                 logger.info(
                     f"Stage {i+1} is a cycle group: {stage.cycle_group.cycle_id}"
                 )
-                # Execute cycle group
-                cycle_results = self._execute_cycle_group(
+                # Execute cycle group and get downstream nodes
+                cycle_results, downstream_nodes = self._execute_cycle_group(
                     workflow, stage.cycle_group, state, task_manager
                 )
                 results.update(cycle_results)
+
+                # Add downstream nodes to pending execution
+                if downstream_nodes:
+                    pending_post_cycle_nodes.update(downstream_nodes)
+                    logger.info(
+                        f"Added {len(downstream_nodes)} nodes for post-cycle execution"
+                    )
             else:
                 # Execute DAG nodes using extracted method
                 dag_results = self._execute_dag_portion(
@@ -430,6 +441,40 @@ class CyclicWorkflowExecutor:
                 )
                 results.update(dag_results)
 
+                # Remove executed nodes from pending
+                for node in stage.nodes:
+                    pending_post_cycle_nodes.discard(node)
+
+        # Execute any remaining post-cycle nodes
+        if pending_post_cycle_nodes:
+            logger.info(f"Executing {len(pending_post_cycle_nodes)} post-cycle nodes")
+
+            # We need to include all dependencies of post-cycle nodes to ensure they get their inputs
+            # This includes both cycle and non-cycle dependencies
+            nodes_to_execute = set(pending_post_cycle_nodes)
+
+            # For each post-cycle node, check if it has unexecuted dependencies
+            for node in list(pending_post_cycle_nodes):
+                for pred in workflow.graph.predecessors(node):
+                    if pred not in state.node_outputs and pred not in nodes_to_execute:
+                        # This predecessor hasn't been executed yet
+                        nodes_to_execute.add(pred)
+                        logger.debug(
+                            f"Adding dependency {pred} for post-cycle node {node}"
+                        )
+
+            # Order them topologically
+            subgraph = workflow.graph.subgraph(nodes_to_execute)
+            if nx.is_directed_acyclic_graph(subgraph):
+                ordered_nodes = list(nx.topological_sort(subgraph))
+            else:
+                ordered_nodes = list(nodes_to_execute)
+
+            post_cycle_results = self._execute_dag_portion(
+                workflow, ordered_nodes, state, task_manager
+            )
+            results.update(post_cycle_results)
+
         return results
 
     def _execute_dag_portion(
@@ -485,7 +530,7 @@ class CyclicWorkflowExecutor:
 
         for cycle_group in cycle_groups:
             logger.info(f"Executing cycle group: {cycle_group.cycle_id}")
-            cycle_results = self._execute_cycle_group(
+            cycle_results, _ = self._execute_cycle_group(
                 workflow, cycle_group, state, task_manager
             )
             results.update(cycle_results)
@@ -547,9 +592,9 @@ class CyclicWorkflowExecutor:
             Cycle execution results
         """
         cycle_id = cycle_group.cycle_id
-        logger.info(f"*** EXECUTING CYCLE GROUP: {cycle_id} ***")
-        logger.info(f"Cycle nodes: {cycle_group.nodes}")
-        logger.info(f"Cycle edges: {cycle_group.edges}")
+        logger.info(f"Executing cycle group: {cycle_id}")
+        logger.debug(f"Cycle nodes: {cycle_group.nodes}")
+        logger.debug(f"Cycle edges: {cycle_group.edges}")
 
         # Get cycle configuration from first edge
         cycle_config = {}
@@ -636,7 +681,13 @@ class CyclicWorkflowExecutor:
 
                 # Execute nodes in cycle
                 iteration_results = {}
-                for node_id in cycle_group.get_execution_order(workflow.graph):
+                execution_order = cycle_group.get_execution_order(workflow.graph)
+                logger.debug(
+                    f"Cycle {cycle_id} iteration {loop_count}: execution_order={execution_order}"
+                )
+
+                for node_id in execution_order:
+                    logger.debug(f"Executing {node_id} in iteration {loop_count}")
                     node_result = self._execute_node(
                         workflow,
                         node_id,
@@ -644,14 +695,35 @@ class CyclicWorkflowExecutor:
                         cycle_state,
                         cycle_edges=cycle_group.edges,
                         previous_iteration_results=previous_iteration_results,
+                        current_iteration_results=iteration_results,  # CRITICAL FIX: Pass current iteration results
                         task_manager=task_manager,
                         iteration=loop_count,
                     )
-                    iteration_results[node_id] = node_result
-                    state.node_outputs[node_id] = node_result
-
-                # Update results for this iteration
-                results.update(iteration_results)
+                    # CRITICAL FIX: Handle None node results gracefully
+                    if node_result is not None:
+                        iteration_results[node_id] = node_result
+                    else:
+                        logger.debug(
+                            f"Node {node_id} returned None result in iteration {loop_count}"
+                        )
+                        # Store None result to track execution but don't propagate
+                        iteration_results[node_id] = None
+                    # CRITICAL FIX: Don't update state.node_outputs during iteration
+                    # This was causing non-deterministic behavior because later nodes
+                    # in the same iteration could see current iteration results
+                    # instead of previous iteration results
+
+                # Update results for this iteration - filter out None values for final results
+                for node_id, node_result in iteration_results.items():
+                    if node_result is not None:
+                        results[node_id] = node_result
+
+                # CRITICAL FIX: Update state.node_outputs AFTER the entire iteration
+                # This ensures all nodes in the current iteration only see previous iteration results
+                for node_id, node_result in iteration_results.items():
+                    # Only update state with non-None results to avoid downstream issues
+                    if node_result is not None:
+                        state.node_outputs[node_id] = node_result
 
                 # Store this iteration's results for next iteration
                 previous_iteration_results = iteration_results.copy()
@@ -719,14 +791,243 @@ class CyclicWorkflowExecutor:
                     except Exception as e:
                         logger.warning(f"Failed to update iteration task: {e}")
 
+                # CRITICAL FIX: Check for natural termination based on cycle connection pattern
+                # Different patterns:
+                # 1. true_output → continue cycle when True, terminate when False
+                # 2. false_output → continue cycle when False, terminate when True
+                natural_termination_detected = False
+                termination_reasons = []  # Collect all termination reasons
+
+                for node_id in cycle_group.nodes:
+                    if node_id in iteration_results:
+                        node_result = iteration_results[node_id]
+                        if (
+                            isinstance(node_result, dict)
+                            and "condition_result" in node_result
+                        ):
+                            condition_result = node_result.get("condition_result")
+
+                            # Check what type of cycle connection this node has
+                            node_has_true_output_cycle = False
+                            node_has_false_output_cycle = False
+
+                            for pred, succ, edge_data in cycle_group.edges:
+                                if pred == node_id and edge_data.get("mapping"):
+                                    mapping = edge_data["mapping"]
+                                    if "true_output" in mapping:
+                                        node_has_true_output_cycle = True
+                                    if "false_output" in mapping:
+                                        node_has_false_output_cycle = True
+
+                            # Only check nodes that are actually part of cycle connections
+                            if (
+                                node_has_true_output_cycle
+                                or node_has_false_output_cycle
+                            ):
+                                # Determine if cycle should terminate based on connection pattern
+                                should_terminate_naturally = False
+                                if node_has_true_output_cycle and not condition_result:
+                                    # true_output cycle: terminate when condition becomes False
+                                    should_terminate_naturally = True
+                                    reason = f"{node_id} condition=False in true_output cycle"
+                                    termination_reasons.append(reason)
+                                elif node_has_false_output_cycle and condition_result:
+                                    # false_output cycle: terminate when condition becomes True
+                                    should_terminate_naturally = True
+                                    reason = f"{node_id} condition=True in false_output cycle"
+                                    termination_reasons.append(reason)
+
+                                if should_terminate_naturally:
+                                    natural_termination_detected = True
+                                    should_terminate = True
+                                    # DON'T break - check all SwitchNodes for comprehensive logging
+
+                # Log all termination reasons if any found
+                if natural_termination_detected:
+                    combined_reason = "; ".join(termination_reasons)
+                    logger.info(
+                        f"Cycle {cycle_id} naturally terminating: {combined_reason}"
+                    )
+
                 if should_terminate:
+                    termination_reason = (
+                        "max_iterations"
+                        if loop_count
+                        >= cycle_config.get("max_iterations", float("inf"))
+                        else (
+                            "natural" if natural_termination_detected else "convergence"
+                        )
+                    )
                     logger.info(
                         f"Cycle {cycle_id} terminating after {loop_count} iterations"
                     )
+
+                    # CRITICAL FIX: Ensure final cycle results are in state for downstream nodes
+                    # This is essential for natural cycle termination where downstream nodes
+                    # need access to the final iteration data
+                    for node_id in cycle_group.exit_nodes:
+                        if node_id in iteration_results:
+                            final_result = iteration_results[node_id]
+                            state.node_outputs[node_id] = final_result
+                            logger.debug(
+                                f"Updated state.node_outputs[{node_id}] with final iteration result for downstream nodes"
+                            )
+
+                    # CRITICAL: For exit nodes that are conditional (like SwitchNode),
+                    # we need to ensure downstream nodes can access the appropriate outputs
+                    # This handles both max iteration termination AND natural termination
+                    logger.info(
+                        f"Processing exit nodes: {cycle_group.exit_nodes}, natural_termination_detected: {natural_termination_detected}"
+                    )
+                    for exit_node_id in cycle_group.exit_nodes:
+                        exit_node = workflow.get_node(exit_node_id)
+                        if exit_node and exit_node.__class__.__name__ == "SwitchNode":
+                            if exit_node_id in iteration_results:
+                                exit_result = iteration_results[exit_node_id]
+
+                                # Check if we terminated at max iterations with condition=true
+                                # In this case, synthesize false_output for downstream nodes
+                                max_iterations = cycle_config.get(
+                                    "max_iterations", float("inf")
+                                )
+                                terminated_at_max = loop_count >= max_iterations
+
+                                if (
+                                    terminated_at_max
+                                    and exit_result is not None
+                                    and exit_result.get("condition_result", False)
+                                    and exit_result.get("true_output")
+                                ):
+                                    # Find the actual last data from the cycle
+                                    # Look for the node that feeds into this exit node
+                                    last_cycle_data = None
+
+                                    # Check which nodes feed into the exit node
+                                    for pred in workflow.graph.predecessors(
+                                        exit_node_id
+                                    ):
+                                        if (
+                                            pred in cycle_group.nodes
+                                            and pred in iteration_results
+                                        ):
+                                            pred_result = iteration_results[pred]
+                                            if (
+                                                isinstance(pred_result, dict)
+                                                and "result" in pred_result
+                                            ):
+                                                last_cycle_data = pred_result["result"]
+                                                logger.debug(
+                                                    f"Using data from {pred} for false_output: {last_cycle_data}"
+                                                )
+                                                break
+
+                                    # Synthesize a false_output with the actual last iteration's data
+                                    exit_result["false_output"] = (
+                                        last_cycle_data or exit_result["true_output"]
+                                    )
+                                    state.node_outputs[exit_node_id] = exit_result
+                                    logger.debug(
+                                        f"Synthesized false_output for {exit_node_id} on max iteration termination with data: {exit_result['false_output']}"
+                                    )
+
+                                # For natural termination (condition=false), the SwitchNode should already
+                                # have the correct false_output set, so we just ensure it's in state
+                                elif (
+                                    not terminated_at_max
+                                    and exit_result is not None
+                                    and not exit_result.get("condition_result", True)
+                                ):
+                                    # Natural termination - condition became false
+                                    # The SwitchNode should have correctly set false_output
+                                    state.node_outputs[exit_node_id] = exit_result
+                                    logger.debug(
+                                        f"Natural termination: {exit_node_id} condition_result={exit_result.get('condition_result')}, false_output present={exit_result.get('false_output') is not None}"
+                                    )
+
+                                # CRITICAL FIX: For exit nodes that have downstream connections via false_output
+                                # but the cycle terminated due to a different node, we need to synthesize termination data
+                                elif (
+                                    natural_termination_detected
+                                    and exit_result is not None
+                                ):
+                                    logger.debug(
+                                        f"Processing exit node {exit_node_id} for natural termination synthesis"
+                                    )
+                                    # Check if this exit node has downstream connections via false_output
+                                    has_false_output_connections = False
+                                    for succ in workflow.graph.successors(exit_node_id):
+                                        if (
+                                            succ not in cycle_group.nodes
+                                        ):  # Downstream node outside cycle
+                                            logger.debug(
+                                                f"  Checking downstream node {succ}"
+                                            )
+                                            for edge_data in workflow.graph[
+                                                exit_node_id
+                                            ][succ].values():
+                                                # Handle both dict and string edge_data formats
+                                                if isinstance(edge_data, dict):
+                                                    mapping = edge_data.get(
+                                                        "mapping", {}
+                                                    )
+                                                else:
+                                                    # Old format where edge_data might be a string
+                                                    logger.debug(
+                                                        f"    Legacy edge_data format: {edge_data} (type: {type(edge_data)})"
+                                                    )
+                                                    mapping = {}
+                                                logger.debug(
+                                                    f"    Edge mapping: {mapping}"
+                                                )
+                                                if "false_output" in mapping:
+                                                    has_false_output_connections = True
+                                                    logger.debug(
+                                                        f"    Found false_output connection to {succ}"
+                                                    )
+                                                    break
+
+                                    logger.debug(
+                                        f"  Exit node {exit_node_id} has_false_output_connections: {has_false_output_connections}"
+                                    )
+                                    logger.debug(
+                                        f"  Exit node {exit_node_id} current false_output: {exit_result.get('false_output')}"
+                                    )
+
+                                    # If this exit node has false_output connections but the cycle terminated naturally
+                                    # due to another node, synthesize appropriate termination data
+                                    if (
+                                        has_false_output_connections
+                                        and exit_result.get("false_output") is None
+                                    ):
+                                        # Use the current true_output data as termination data for false_output
+                                        termination_data = exit_result.get(
+                                            "true_output"
+                                        )
+                                        if termination_data is not None:
+                                            exit_result["false_output"] = (
+                                                termination_data
+                                            )
+                                            state.node_outputs[exit_node_id] = (
+                                                exit_result
+                                            )
+                                            logger.info(
+                                                f"Synthesized false_output for {exit_node_id} on natural termination: {termination_data}"
+                                            )
+
                     break
 
                 logger.info(f"Cycle {cycle_id} continuing to next iteration")
 
+            # Get downstream nodes if cycle has terminated
+            downstream_nodes = None
+            if should_terminate:
+                # Get nodes that depend on cycle output
+                downstream_nodes = cycle_group.get_downstream_nodes(workflow)
+                if downstream_nodes:
+                    logger.info(
+                        f"Cycle {cycle_id} has downstream nodes: {downstream_nodes}"
+                    )
+
             # Complete cycle group task
             if cycle_task_id and task_manager:
                 try:
@@ -751,7 +1052,7 @@ class CyclicWorkflowExecutor:
             summary = cycle_state.get_summary()
             logger.info(f"Cycle {cycle_id} completed: {summary}")
 
-            return results
+            return results, downstream_nodes
 
     def _execute_node(
         self,
@@ -761,6 +1062,9 @@ class CyclicWorkflowExecutor:
         cycle_state: CycleState | None = None,
         cycle_edges: list[tuple] | None = None,
         previous_iteration_results: dict[str, Any] | None = None,
+        current_iteration_results: (
+            dict[str, Any] | None
+        ) = None,  # CRITICAL FIX: Current iteration results
         task_manager: TaskManager | None = None,
         iteration: int | None = None,
     ) -> Any:
@@ -792,7 +1096,26 @@ class CyclicWorkflowExecutor:
         in_cycle = cycle_state is not None
         is_cycle_iteration = in_cycle and cycle_state.iteration > 0
 
-        for pred, _, edge_data in workflow.graph.in_edges(node_id, data=True):
+        # CRITICAL FIX: Process edges in priority order - non-cycle edges first, then cycle edges
+        # This ensures cycle data overwrites non-cycle data when mapping to the same parameter
+        all_edges = list(workflow.graph.in_edges(node_id, data=True))
+
+        # Sort edges: non-cycle edges first, cycle edges second (for priority)
+        non_cycle_edges = []
+        cycle_edges = []
+
+        for pred, _, edge_data in all_edges:
+            # CRITICAL FIX: Synthetic edges are also cycle edges and should have priority
+            is_cycle_edge = edge_data.get(
+                "cycle", False
+            )  # Include synthetic cycle edges
+            if is_cycle_edge:
+                cycle_edges.append((pred, _, edge_data))
+            else:
+                non_cycle_edges.append((pred, _, edge_data))
+
+        # Process non-cycle edges first, then cycle edges (so cycle data has priority)
+        for pred, _, edge_data in non_cycle_edges + cycle_edges:
             # Check if this edge is a cycle edge (but NOT synthetic)
             is_cycle_edge = edge_data.get("cycle", False) and not edge_data.get(
                 "synthetic", False
@@ -802,20 +1125,42 @@ class CyclicWorkflowExecutor:
             if is_cycle_edge and is_cycle_iteration and previous_iteration_results:
                 # For cycle edges after first iteration, use previous iteration results
                 pred_output = previous_iteration_results.get(pred)
+                logger.debug(
+                    f"Cycle edge {pred} -> {node_id}: using previous iteration results"
+                )
+            elif current_iteration_results and pred in current_iteration_results:
+                # For non-cycle edges, prefer current iteration results over stale state
+                pred_output = current_iteration_results[pred]
+                logger.debug(
+                    f"Non-cycle edge {pred} -> {node_id}: using current iteration results"
+                )
             elif pred in state.node_outputs:
-                # For non-cycle edges or first iteration, use normal state
+                # For non-cycle edges or first iteration, use normal state as fallback
                 pred_output = state.node_outputs[pred]
+                logger.debug(
+                    f"Non-cycle edge {pred} -> {node_id}: using state fallback"
+                )
             else:
                 # No output available
+                logger.debug(f"No output available for {pred} -> {node_id}")
                 continue
 
             if pred_output is None:
                 continue
 
-            # Apply mapping
+            # Apply mapping - with None safety check
             mapping = edge_data.get("mapping", {})
+            pred_output_info = (
+                "None"
+                if pred_output is None
+                else (
+                    list(pred_output.keys())
+                    if isinstance(pred_output, dict)
+                    else type(pred_output)
+                )
+            )
             logger.debug(
-                f"Edge {pred} -> {node_id}: mapping = {mapping}, pred_output keys = {list(pred_output.keys()) if isinstance(pred_output, dict) else type(pred_output)}"
+                f"Edge {pred} -> {node_id}: mapping = {mapping}, pred_output keys = {pred_output_info}"
             )
             for src_key, dst_key in mapping.items():
                 # Handle nested output access
@@ -1033,15 +1378,57 @@ class ExecutionPlan:
         # Track which nodes have been scheduled
         scheduled = set()
 
+        # Identify nodes that depend on cycle exit nodes through specific outputs
+        # that are only available when the cycle terminates (e.g., false_output of a cycle-controlling switch)
+        nodes_depending_on_cycles = set()
+        for cycle_id, cycle_group in self.cycle_groups.items():
+            for exit_node in cycle_group.exit_nodes:
+                exit_node_obj = workflow.get_node(exit_node)
+                # Special handling for SwitchNodes that control cycles
+                if exit_node_obj and exit_node_obj.__class__.__name__ == "SwitchNode":
+                    # For switch nodes, check which output is used for the cycle
+                    # and which would be used for exit
+                    for source, target, edge_data in workflow.graph.out_edges(
+                        exit_node, data=True
+                    ):
+                        if target not in cycle_group.nodes:
+                            # This edge goes outside the cycle
+                            mapping = edge_data.get("mapping", {})
+                            # Check if this uses an output that indicates cycle termination
+                            for src_port, _ in mapping.items():
+                                if (
+                                    "false" in src_port.lower()
+                                    or "exit" in src_port.lower()
+                                ):
+                                    # This node depends on cycle termination
+                                    nodes_depending_on_cycles.add(target)
+                                    logger.debug(
+                                        f"Node {target} depends on cycle {cycle_id} exit condition via {exit_node}.{src_port}"
+                                    )
+                else:
+                    # For non-switch nodes, use the original logic
+                    for successor in workflow.graph.successors(exit_node):
+                        if successor not in cycle_group.nodes:
+                            nodes_depending_on_cycles.add(successor)
+                            logger.debug(
+                                f"Node {successor} depends on cycle {cycle_id} exit node {exit_node}"
+                            )
+
         logger.debug(
             f"Building stages - cycle_groups: {list(self.cycle_groups.keys())}"
         )
         logger.debug(f"Building stages - topo_order: {topo_order}")
+        logger.debug(f"Nodes depending on cycles: {nodes_depending_on_cycles}")
 
         for node_id in topo_order:
             if node_id in scheduled:
                 continue
 
+            # Skip nodes that depend on cycle outputs - they'll be executed post-cycle
+            if node_id in nodes_depending_on_cycles:
+                logger.debug(f"Skipping {node_id} - depends on cycle output")
+                continue
+
             # Check if node is part of a cycle
             in_cycle_id = None
             found_cycle_group = None
@@ -1184,6 +1571,22 @@ class CycleGroup:
         self.exit_nodes = exit_nodes
         self.edges = edges
 
+    def get_downstream_nodes(self, workflow: Workflow) -> set[str]:
+        """Get all nodes that depend on this cycle's output.
+
+        Args:
+            workflow: The workflow containing this cycle
+
+        Returns:
+            Set of node IDs that are downstream from the cycle
+        """
+        downstream = set()
+        for exit_node in self.exit_nodes:
+            for successor in workflow.graph.successors(exit_node):
+                if successor not in self.nodes:  # Not part of cycle
+                    downstream.add(successor)
+        return downstream
+
     def get_execution_order(self, full_graph: nx.DiGraph) -> list[str]:
         """Get execution order for nodes in cycle.
 
@@ -1194,17 +1597,23 @@ class CycleGroup:
             Ordered list of node IDs
         """
         # Create subgraph with only cycle nodes
-        cycle_subgraph = full_graph.subgraph(self.nodes)
+        cycle_subgraph = full_graph.subgraph(self.nodes).copy()
 
-        # Try topological sort on the subgraph (might work if cycle edges removed)
-        try:
-            # Remove cycle edges temporarily
-            temp_graph = cycle_subgraph.copy()
-            for source, target, _ in self.edges:
-                if temp_graph.has_edge(source, target):
-                    temp_graph.remove_edge(source, target)
+        # Remove only non-synthetic cycle edges
+        # Synthetic edges represent real dependencies and should be kept
+        edges_to_remove = []
+        for source, target, data in cycle_subgraph.edges(data=True):
+            # Only remove edges that are cycle edges and NOT synthetic
+            if data.get("cycle", False) and not data.get("synthetic", False):
+                edges_to_remove.append((source, target))
 
-            return list(nx.topological_sort(temp_graph))
+        # Remove the identified edges
+        for source, target in edges_to_remove:
+            cycle_subgraph.remove_edge(source, target)
+
+        # Try topological sort on the subgraph
+        try:
+            return list(nx.topological_sort(cycle_subgraph))
         except (nx.NetworkXError, nx.NetworkXUnfeasible):
             # Fall back to entry nodes first, then others
             order = list(self.entry_nodes)

{kailash-0.9.1.dist-info → kailash-0.9.3.dist-info}/METADATA

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