kailash 0.4.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

kailash/workflow/builder.py

@@ -21,7 +21,7 @@ class WorkflowBuilder:
 
     def add_node(
         self,
-        node_type: str,
+        node_type: str | type | Any,
         node_id: str | None = None,
         config: dict[str, Any] | None = None,
     ) -> str:
@@ -29,9 +29,9 @@ class WorkflowBuilder:
         Add a node to the workflow.
 
         Args:
-            node_type: Node type name
+            node_type: Node type name (string), Node class, or Node instance
             node_id: Unique identifier for this node (auto-generated if not provided)
-            config: Configuration for the node
+            config: Configuration for the node (ignored if node_type is an instance)
 
         Returns:
             Node ID (useful for method chaining)
@@ -48,11 +48,80 @@ class WorkflowBuilder:
                 f"Node ID '{node_id}' already exists in workflow"
             )
 
-        self.nodes[node_id] = {"type": node_type, "config": config or {}}
+        # Import Node here to avoid circular imports
+        from kailash.nodes.base import Node
+
+        # Handle different input types
+        if isinstance(node_type, str):
+            # String node type name
+            self.nodes[node_id] = {"type": node_type, "config": config or {}}
+            type_name = node_type
+        elif isinstance(node_type, type) and issubclass(node_type, Node):
+            # Node class
+            self.nodes[node_id] = {
+                "type": node_type.__name__,
+                "config": config or {},
+                "class": node_type,
+            }
+            type_name = node_type.__name__
+        elif hasattr(node_type, "__class__") and issubclass(node_type.__class__, Node):
+            # Node instance
+            self.nodes[node_id] = {
+                "instance": node_type,
+                "type": node_type.__class__.__name__,
+            }
+            type_name = node_type.__class__.__name__
+        else:
+            raise WorkflowValidationError(
+                f"Invalid node type: {type(node_type)}. "
+                "Expected: str (node type name), Node class, or Node instance"
+            )
 
-        logger.info(f"Added node '{node_id}' of type '{node_type}'")
+        logger.info(f"Added node '{node_id}' of type '{type_name}'")
         return node_id
 
+    def add_node_instance(self, node_instance: Any, node_id: str | None = None) -> str:
+        """
+        Add a node instance to the workflow.
+
+        This is a convenience method for adding pre-configured node instances.
+
+        Args:
+            node_instance: Pre-configured node instance
+            node_id: Unique identifier for this node (auto-generated if not provided)
+
+        Returns:
+            Node ID
+
+        Raises:
+            WorkflowValidationError: If node_id is already used or instance is invalid
+        """
+        return self.add_node(node_instance, node_id)
+
+    def add_node_type(
+        self,
+        node_type: str,
+        node_id: str | None = None,
+        config: dict[str, Any] | None = None,
+    ) -> str:
+        """
+        Add a node by type name to the workflow.
+
+        This is the original string-based method, provided for clarity and backward compatibility.
+
+        Args:
+            node_type: Node type name as string
+            node_id: Unique identifier for this node (auto-generated if not provided)
+            config: Configuration for the node
+
+        Returns:
+            Node ID
+
+        Raises:
+            WorkflowValidationError: If node_id is already used
+        """
+        return self.add_node(node_type, node_id, config)
+
     def add_connection(
         self, from_node: str, from_output: str, to_node: str, to_input: str
     ) -> None:
@@ -149,11 +218,25 @@ class WorkflowBuilder:
         # Add nodes to workflow
         for node_id, node_info in self.nodes.items():
             try:
-                node_type = node_info["type"]
-                node_config = node_info.get("config", {})
-
-                # Add the node to workflow
-                workflow._add_node_internal(node_id, node_type, node_config)
+                if "instance" in node_info:
+                    # Node instance was provided
+                    workflow.add_node(
+                        node_id=node_id, node_or_type=node_info["instance"]
+                    )
+                elif "class" in node_info:
+                    # Node class was provided
+                    node_class = node_info["class"]
+                    node_config = node_info.get("config", {})
+                    workflow.add_node(
+                        node_id=node_id, node_or_type=node_class, **node_config
+                    )
+                else:
+                    # String node type
+                    node_type = node_info["type"]
+                    node_config = node_info.get("config", {})
+                    workflow.add_node(
+                        node_id=node_id, node_or_type=node_type, **node_config
+                    )
             except Exception as e:
                 raise WorkflowValidationError(
                     f"Failed to add node '{node_id}' to workflow: {e}"

kailash/workflow/cyclic_runner.py

@@ -297,19 +297,29 @@ class CyclicWorkflowExecutor:
             entry_nodes = set()
             exit_nodes = set()
 
+            # First, collect all nodes in the cycle
             for source, target, data in cycle_edges:
                 cycle_nodes.add(source)
                 cycle_nodes.add(target)
 
+            # Then identify entry and exit nodes
+            for node in cycle_nodes:
                 # Entry nodes have incoming edges from non-cycle nodes
-                for pred in workflow.graph.predecessors(target):
+                for pred in workflow.graph.predecessors(node):
                     if pred not in cycle_nodes:
-                        entry_nodes.add(target)
+                        entry_nodes.add(node)
+                        logger.debug(
+                            f"Cycle {cycle_id}: Node {node} is an entry node (has predecessor {pred})"
+                        )
 
                 # Exit nodes have outgoing edges to non-cycle nodes
-                for succ in workflow.graph.successors(source):
+                for succ in workflow.graph.successors(node):
                     if succ not in cycle_nodes:
-                        exit_nodes.add(source)
+                        exit_nodes.add(node)
+
+            logger.debug(
+                f"Cycle {cycle_id}: nodes={cycle_nodes}, entry_nodes={entry_nodes}, exit_nodes={exit_nodes}"
+            )
 
             plan.add_cycle_group(
                 cycle_id=cycle_id,
@@ -320,7 +330,7 @@ class CyclicWorkflowExecutor:
             )
 
         # Build execution stages
-        plan.build_stages(topo_order, dag_graph)
+        plan.build_stages(topo_order, dag_graph, workflow)
 
         return plan
 
@@ -516,12 +526,11 @@ class CyclicWorkflowExecutor:
                     f"Cycle {cycle_id} iteration now at {cycle_state.iteration} (after update)"
                 )
 
-                # Check max iterations (built into monitor.record_iteration)
-                if cycle_state.iteration >= cycle_config.get(
-                    "max_iterations", float("inf")
-                ):
+                # Check max iterations - loop_count represents actual iterations executed
+                max_iterations = cycle_config.get("max_iterations", float("inf"))
+                if loop_count >= max_iterations:
                     logger.info(
-                        f"Cycle {cycle_id} reached max iterations: {cycle_state.iteration}"
+                        f"Cycle {cycle_id} reached max iterations: {loop_count}/{max_iterations}"
                     )
                     should_terminate = True
 
@@ -629,6 +638,10 @@ class CyclicWorkflowExecutor:
         # Gather inputs from connections
         inputs = {}
 
+        logger.debug(
+            f"_execute_node {node_id}: state.node_outputs keys = {list(state.node_outputs.keys())}"
+        )
+
         # Check if we're in a cycle and this is not the first iteration
         in_cycle = cycle_state is not None
         is_cycle_iteration = in_cycle and cycle_state.iteration > 0
@@ -643,9 +656,6 @@ 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"Using previous iteration result for {pred} -> {node_id}: {type(pred_output)} keys={list(pred_output.keys()) if isinstance(pred_output, dict) else 'not dict'}"
-                )
             elif pred in state.node_outputs:
                 # For non-cycle edges or first iteration, use normal state
                 pred_output = state.node_outputs[pred]
@@ -658,10 +668,9 @@ class CyclicWorkflowExecutor:
 
             # Apply mapping
             mapping = edge_data.get("mapping", {})
-            if is_cycle_edge and is_cycle_iteration:
-                logger.debug(
-                    f"Applying cycle mapping: {mapping} from {pred} to {node_id}"
-                )
+            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)}"
+            )
             for src_key, dst_key in mapping.items():
                 # Handle nested output access
                 if "." in src_key:
@@ -677,10 +686,9 @@ class CyclicWorkflowExecutor:
                         inputs[dst_key] = value
                 elif isinstance(pred_output, dict) and src_key in pred_output:
                     inputs[dst_key] = pred_output[src_key]
-                    if is_cycle_edge and is_cycle_iteration:
-                        logger.debug(
-                            f"Mapped {src_key}={pred_output[src_key]} to {dst_key}"
-                        )
+                    logger.debug(
+                        f"Mapped {src_key} -> {dst_key}: {type(pred_output[src_key])}, length={len(pred_output[src_key]) if hasattr(pred_output[src_key], '__len__') else 'N/A'}"
+                    )
                 elif src_key == "output":
                     # Default output mapping
                     inputs[dst_key] = pred_output
@@ -706,20 +714,15 @@ class CyclicWorkflowExecutor:
         # Recursively filter None values from context to avoid security validation errors
         context = self._filter_none_values(context)
 
-        # Debug inputs before merging
-        if cycle_state and cycle_state.iteration > 0:
-            logger.debug(f"Inputs gathered from connections: {inputs}")
-
         # Merge node config with inputs
         # Order: config < initial_parameters < connection inputs
         merged_inputs = {**node.config}
 
-        # Add initial parameters if available and node hasn't been executed yet
+        # Add initial parameters if available
+        # For cycle nodes, initial parameters should be available throughout all iterations
         if hasattr(state, "initial_parameters") and node_id in state.initial_parameters:
-            if node_id not in state.node_outputs or (
-                cycle_state and cycle_state.iteration == 0
-            ):
-                # Use initial parameters on first execution
+            if node_id not in state.node_outputs or cycle_state is not None:
+                # Use initial parameters on first execution or for any cycle iteration
                 merged_inputs.update(state.initial_parameters[node_id])
 
         # Connection inputs override everything
@@ -728,6 +731,10 @@ class CyclicWorkflowExecutor:
         # Filter out None values to avoid security validation errors
         merged_inputs = {k: v for k, v in merged_inputs.items() if v is not None}
 
+        logger.debug(
+            f"Final merged_inputs for {node_id}: keys={list(merged_inputs.keys())}"
+        )
+
         # Create task for node execution if task manager available
         task = None
         if task_manager and state.run_id:
@@ -769,11 +776,6 @@ class CyclicWorkflowExecutor:
         logger.debug(
             f"Executing node: {node_id} (iteration: {cycle_state.iteration if cycle_state else 'N/A'})"
         )
-        logger.debug(f"Node inputs: {list(merged_inputs.keys())}")
-        if cycle_state:
-            logger.debug(
-                f"Input values - value: {merged_inputs.get('value')}, counter: {merged_inputs.get('counter')}"
-            )
 
         try:
             with collector.collect(node_id=node_id) as metrics_context:
@@ -858,12 +860,15 @@ class ExecutionPlan:
             edges=edges,
         )
 
-    def build_stages(self, topo_order: list[str], dag_graph: nx.DiGraph) -> None:
+    def build_stages(
+        self, topo_order: list[str], dag_graph: nx.DiGraph, workflow: Workflow
+    ) -> None:
         """Build execution stages.
 
         Args:
             topo_order: Topological order of DAG nodes
             dag_graph: DAG portion of the graph
+            workflow: The full workflow for checking dependencies
         """
         # Track which nodes have been scheduled
         scheduled = set()
@@ -894,18 +899,83 @@ class ExecutionPlan:
                 f"in_cycle_id value: {in_cycle_id}, found_cycle_group: {found_cycle_group is not None}"
             )
             if found_cycle_group is not None:
-                logger.debug(f"Scheduling cycle group {in_cycle_id} for node {node_id}")
-                # Schedule entire cycle group
-                self.stages.append(
-                    ExecutionStage(is_cycle=True, cycle_group=found_cycle_group)
+                # Check if all DAG dependencies of cycle entry nodes are satisfied
+                can_schedule_cycle = True
+                logger.debug(
+                    f"Checking dependencies for cycle {in_cycle_id}, entry_nodes: {found_cycle_group.entry_nodes}"
                 )
-                scheduled.update(found_cycle_group.nodes)
+                for entry_node in found_cycle_group.entry_nodes:
+                    # Check all predecessors of this entry node in the FULL workflow graph
+                    # (dag_graph only contains DAG edges, not connections to cycle nodes)
+                    preds = list(workflow.graph.predecessors(entry_node))
+                    logger.debug(
+                        f"Entry node {entry_node} has predecessors: {preds}, scheduled: {scheduled}"
+                    )
+                    for pred in preds:
+                        # Skip self-cycles and nodes within the same cycle group
+                        logger.debug(
+                            f"Checking pred {pred}: in scheduled? {pred in scheduled}, in cycle? {pred in found_cycle_group.nodes}"
+                        )
+                        if (
+                            pred not in scheduled
+                            and pred not in found_cycle_group.nodes
+                        ):
+                            # This predecessor hasn't been scheduled yet
+                            logger.debug(
+                                f"Cannot schedule cycle {in_cycle_id} yet - entry node {entry_node} "
+                                f"depends on unscheduled node {pred}"
+                            )
+                            can_schedule_cycle = False
+                            break
+                    if not can_schedule_cycle:
+                        break
+
+                if can_schedule_cycle:
+                    logger.debug(
+                        f"Scheduling cycle group {in_cycle_id} for node {node_id}"
+                    )
+                    # Schedule entire cycle group
+                    self.stages.append(
+                        ExecutionStage(is_cycle=True, cycle_group=found_cycle_group)
+                    )
+                    scheduled.update(found_cycle_group.nodes)
+                else:
+                    # Skip this node for now, it will be scheduled when its dependencies are met
+                    logger.debug(
+                        f"Deferring cycle group {in_cycle_id} - dependencies not met"
+                    )
+                    continue
             else:
                 logger.debug(f"Scheduling DAG node {node_id}")
                 # Schedule DAG node
                 self.stages.append(ExecutionStage(is_cycle=False, nodes=[node_id]))
                 scheduled.add(node_id)
 
+        # After processing all nodes in topological order, check for any unscheduled cycle groups
+        for cycle_id, cycle_group in self.cycle_groups.items():
+            if not any(node in scheduled for node in cycle_group.nodes):
+                # This cycle group hasn't been scheduled yet
+                # Check if all dependencies are now satisfied
+                can_schedule = True
+                for entry_node in cycle_group.entry_nodes:
+                    for pred in workflow.graph.predecessors(entry_node):
+                        if pred not in scheduled and pred not in cycle_group.nodes:
+                            logger.warning(
+                                f"Cycle group {cycle_id} has unsatisfied dependency: "
+                                f"{entry_node} depends on {pred}"
+                            )
+                            can_schedule = False
+                            break
+                    if not can_schedule:
+                        break
+
+                if can_schedule:
+                    logger.debug(f"Scheduling deferred cycle group {cycle_id}")
+                    self.stages.append(
+                        ExecutionStage(is_cycle=True, cycle_group=cycle_group)
+                    )
+                    scheduled.update(cycle_group.nodes)
+
 
 class ExecutionStage:
     """Single stage in execution plan."""

kailash/workflow/graph.py

@@ -657,9 +657,14 @@ class Workflow:
         cycle_groups = {}
         _, cycle_edges = self.separate_dag_and_cycle_edges()
 
-        # First pass: group by cycle_id as before
+        # First pass: group by cycle_id, using edge-based IDs when not specified
         for source, target, data in cycle_edges:
-            cycle_id = data.get("cycle_id", "default")
+            # Generate unique cycle_id based on edge if not provided
+            cycle_id = data.get("cycle_id")
+            if cycle_id is None:
+                # Create unique ID based on the cycle edge
+                cycle_id = f"cycle_{source}_{target}"
+
             if cycle_id not in cycle_groups:
                 cycle_groups[cycle_id] = []
             cycle_groups[cycle_id].append((source, target, data))

kailash/workflow/resilience.py

@@ -6,7 +6,7 @@ including retry policies, fallback nodes, and circuit breakers.
 
 import asyncio
 import time
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from datetime import datetime
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Union
@@ -50,6 +50,16 @@ class RetryPolicy:
 
         return min(delay, self.max_delay)
 
+    def to_dict(self) -> dict:
+        """Convert RetryPolicy to dictionary."""
+        return {
+            "max_retries": self.max_retries,
+            "strategy": self.strategy.value,
+            "base_delay": self.base_delay,
+            "max_delay": self.max_delay,
+            "retry_on": [cls.__name__ for cls in self.retry_on],
+        }
+
 
 @dataclass
 class CircuitBreakerConfig:

{kailash-0.4.2.dist-info → kailash-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.4.2
+Version: 0.6.0
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -61,6 +61,8 @@ Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: aiomysql>=0.2.0
 Requires-Dist: twilio>=9.6.3
 Requires-Dist: qrcode>=8.2
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: bcrypt>=4.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"
@@ -80,8 +82,9 @@ Dynamic: requires-python
   <a href="https://pepy.tech/project/kailash"><img src="https://static.pepy.tech/badge/kailash" alt="Downloads"></a>
   <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License">
   <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
-  <img src="https://img.shields.io/badge/tests-127%20organized-brightgreen.svg" alt="Tests: 127 organized">
-  <img src="https://img.shields.io/badge/test%20structure-reorganized-blue.svg" alt="Test structure: reorganized">
+  <img src="https://img.shields.io/badge/tests-production%20quality-brightgreen.svg" alt="Tests: Production Quality">
+  <img src="https://img.shields.io/badge/docker-integrated-blue.svg" alt="Docker: Integrated">
+  <img src="https://img.shields.io/badge/AI-ollama%20validated-purple.svg" alt="AI: Ollama Validated">
 </p>
 
 <p align="center">
@@ -120,12 +123,14 @@ Dynamic: requires-python
 - 🏭 **Session 067 Enhancements**: Business workflow templates, data lineage tracking, automatic credential rotation
 - 🔄 **Zero-Downtime Operations**: Automatic credential rotation with enterprise notifications and audit trails
 - 🌉 **Enterprise Middleware (v0.4.0)**: Production-ready middleware architecture with real-time agent-frontend communication, dynamic workflows, and AI chat integration
+- ⚡ **Performance Revolution (v0.5.0)**: 10-100x faster parameter resolution, clear async/sync separation, automatic resource management
+- 🧪 **Production-Quality Testing (v0.5.0)**: Comprehensive testing infrastructure with Docker integration, AI workflows, and real-world business scenarios
 
 ## 🏗️ Project Architecture
 
 The Kailash project is organized into three distinct layers:
 
-### Core Architecture (v0.4.0)
+### Core Architecture (v0.5.0)
 ```
 ┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
 │   Frontend      │    │   Middleware     │    │   Kailash Core  │
@@ -150,9 +155,10 @@ kailash_python_sdk/
 1. **SDK Layer** (`src/kailash/`) - The core framework providing:
    - Nodes: Reusable computational units (100+ built-in)
    - Workflows: DAG-based orchestration with cyclic support
-   - Runtime: Unified execution engine (async + enterprise)
-   - Middleware: Enterprise communication layer (NEW in v0.4.0)
+   - Runtime: Unified execution engine with optimized async/sync separation (v0.5.0)
+   - Middleware: Enterprise communication layer (v0.4.0)
    - Security: RBAC/ABAC access control with audit logging
+   - Performance: LRU parameter caching, automatic resource pooling (NEW in v0.5.0)
 
 2. **Application Layer** (`apps/`) - Complete applications including:
    - User Management System (Django++ capabilities)
@@ -175,7 +181,6 @@ pip install kailash[user-management]
 # Everything
 pip install kailash[all]
 ```
->>>>>>> origin/main
 
 ## 🎯 Who Is This For?