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

kailash/workflow/templates.py

@@ -54,7 +54,7 @@ Downstream Consumers:
 
 Examples:
     Optimization cycle template:
-    
+
     >>> from kailash.workflow.templates import CycleTemplates
     >>> workflow = Workflow("optimization", "Quality Optimization")
     >>> workflow.add_node("processor", ProcessorNode())
@@ -66,9 +66,9 @@ Examples:
     ...     convergence="quality > 0.95",
     ...     max_iterations=100
     ... )
-    
+
     Retry cycle with backoff:
-    
+
     >>> cycle_id = CycleTemplates.retry_cycle(
     ...     workflow,
     ...     target_node="api_call",
@@ -76,9 +76,9 @@ Examples:
     ...     backoff_strategy="exponential",
     ...     success_condition="success == True"
     ... )
-    
+
     Direct workflow integration:
-    
+
     >>> # Templates extend Workflow class
     >>> workflow = Workflow("ml_training", "Model Training")
     >>> cycle_id = workflow.add_learning_cycle(
@@ -87,16 +87,16 @@ Examples:
     ...     target_accuracy=0.98,
     ...     early_stopping_patience=10
     ... )
-    
+
     Custom template configuration:
-    
+
     >>> # Numerical convergence with custom tolerance
     >>> cycle_id = workflow.add_convergence_cycle(
     ...     processor_node="newton_raphson",
     ...     tolerance=0.0001,
             max_iterations=1000
         )
-        
+
         # Batch processing for large datasets
         cycle_id = workflow.add_batch_processing_cycle(
             processor_node="data_processor",
@@ -110,10 +110,10 @@ See Also:
     - :doc:`/examples/patterns` for comprehensive pattern examples
 """
 
-from typing import Dict, Any, List, Optional
-from dataclasses import dataclass
-import time
 import math
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
 
 from ..nodes.code import PythonCodeNode
 from . import Workflow
@@ -122,6 +122,7 @@ from . import Workflow
 @dataclass
 class CycleTemplate:
     """Configuration for a cycle template."""
+
     name: str
     description: str
     nodes: List[str]
@@ -133,7 +134,7 @@ class CycleTemplate:
 
 class CycleTemplates:
     """Collection of pre-built cycle templates for common patterns."""
-    
+
     @staticmethod
     def optimization_cycle(
         workflow: Workflow,
@@ -141,14 +142,14 @@ class CycleTemplates:
         evaluator_node: str,
         convergence: str = "quality > 0.9",
         max_iterations: int = 50,
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add an optimization cycle pattern to workflow.
-        
+
         Creates a cycle where a processor generates solutions and an evaluator
         assesses quality, continuing until convergence criteria is met.
-        
+
         Args:
             workflow: Target workflow
             processor_node: Node that generates/improves solutions
@@ -156,10 +157,10 @@ class CycleTemplates:
             convergence: Convergence condition (e.g., "quality > 0.9")
             max_iterations: Maximum iterations before stopping
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("optimization", "Optimization Example")
             >>> workflow.add_node("processor", PythonCodeNode(), code="...")
@@ -171,22 +172,22 @@ class CycleTemplates:
         """
         if cycle_id is None:
             cycle_id = f"optimization_cycle_{int(time.time())}"
-        
+
         # Connect processor to evaluator
         workflow.connect(processor_node, evaluator_node)
-        
+
         # Close the cycle with convergence condition
         workflow.connect(
-            evaluator_node, 
+            evaluator_node,
             processor_node,
             cycle=True,
             max_iterations=max_iterations,
             convergence_check=convergence,
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
-    
+
     @staticmethod
     def retry_cycle(
         workflow: Workflow,
@@ -194,14 +195,14 @@ class CycleTemplates:
         max_retries: int = 3,
         backoff_strategy: str = "exponential",
         success_condition: str = "success == True",
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add a retry cycle pattern to workflow.
-        
+
         Creates a cycle that retries a node operation with configurable
         backoff strategy until success or max retries reached.
-        
+
         Args:
             workflow: Target workflow
             target_node: Node to retry on failure
@@ -209,10 +210,10 @@ class CycleTemplates:
             backoff_strategy: Backoff strategy ("linear", "exponential", "fixed")
             success_condition: Condition that indicates success
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("retry", "Retry Example")
             >>> workflow.add_node("api_call", PythonCodeNode(), code="...")
@@ -223,11 +224,11 @@ class CycleTemplates:
         """
         if cycle_id is None:
             cycle_id = f"retry_cycle_{int(time.time())}"
-        
+
         # Create retry controller node
         retry_controller_id = f"{target_node}_retry_controller"
-        
-        retry_code = f'''
+
+        retry_code = f"""
 import time
 import random
 
@@ -270,13 +271,16 @@ result = {{
     "backoff_time": backoff_time,
     "retry_exhausted": attempt > {max_retries}
 }}
-'''
-        
-        workflow.add_node(retry_controller_id, PythonCodeNode(name=retry_controller_id, code=retry_code))
-        
+"""
+
+        workflow.add_node(
+            retry_controller_id,
+            PythonCodeNode(name=retry_controller_id, code=retry_code),
+        )
+
         # Connect retry controller to target node
         workflow.connect(retry_controller_id, target_node)
-        
+
         # Close the cycle with retry logic
         workflow.connect(
             target_node,
@@ -284,11 +288,11 @@ result = {{
             cycle=True,
             max_iterations=max_retries + 1,
             convergence_check=f"({success_condition}) or (retry_exhausted == True)",
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
-    
+
     @staticmethod
     def data_quality_cycle(
         workflow: Workflow,
@@ -296,14 +300,14 @@ result = {{
         validator_node: str,
         quality_threshold: float = 0.95,
         max_iterations: int = 10,
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add a data quality improvement cycle to workflow.
-        
+
         Creates a cycle where data is cleaned and validated iteratively
         until quality threshold is met.
-        
+
         Args:
             workflow: Target workflow
             cleaner_node: Node that cleans/improves data
@@ -311,10 +315,10 @@ result = {{
             quality_threshold: Minimum quality score to achieve
             max_iterations: Maximum cleaning iterations
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("data_quality", "Data Quality Example")
             >>> workflow.add_node("cleaner", PythonCodeNode(), code="...")
@@ -325,10 +329,10 @@ result = {{
         """
         if cycle_id is None:
             cycle_id = f"data_quality_cycle_{int(time.time())}"
-        
+
         # Connect cleaner to validator
         workflow.connect(cleaner_node, validator_node)
-        
+
         # Close the cycle with quality threshold
         workflow.connect(
             validator_node,
@@ -336,11 +340,11 @@ result = {{
             cycle=True,
             max_iterations=max_iterations,
             convergence_check=f"quality_score >= {quality_threshold}",
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
-    
+
     @staticmethod
     def learning_cycle(
         workflow: Workflow,
@@ -349,14 +353,14 @@ result = {{
         target_accuracy: float = 0.95,
         max_epochs: int = 100,
         early_stopping_patience: int = 10,
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add a machine learning training cycle to workflow.
-        
+
         Creates a cycle for iterative model training with early stopping
         based on validation performance.
-        
+
         Args:
             workflow: Target workflow
             trainer_node: Node that trains the model
@@ -365,10 +369,10 @@ result = {{
             max_epochs: Maximum training epochs
             early_stopping_patience: Epochs to wait without improvement
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("ml_training", "ML Training Example")
             >>> workflow.add_node("trainer", PythonCodeNode(), code="...")
@@ -379,11 +383,11 @@ result = {{
         """
         if cycle_id is None:
             cycle_id = f"learning_cycle_{int(time.time())}"
-        
+
         # Create early stopping controller
         early_stop_controller_id = f"{trainer_node}_early_stop"
-        
-        early_stop_code = f'''
+
+        early_stop_code = f"""
 # Initialize early stopping state
 try:
     best_accuracy = best_accuracy
@@ -429,14 +433,17 @@ result = {{
     "early_stopped": early_stop,
     "training_complete": not should_continue
 }}
-'''
-        
-        workflow.add_node(early_stop_controller_id, PythonCodeNode(name=early_stop_controller_id, code=early_stop_code))
-        
+"""
+
+        workflow.add_node(
+            early_stop_controller_id,
+            PythonCodeNode(name=early_stop_controller_id, code=early_stop_code),
+        )
+
         # Connect the training cycle
         workflow.connect(trainer_node, evaluator_node)
         workflow.connect(evaluator_node, early_stop_controller_id)
-        
+
         # Close the cycle with early stopping logic
         workflow.connect(
             early_stop_controller_id,
@@ -444,35 +451,35 @@ result = {{
             cycle=True,
             max_iterations=max_epochs,
             convergence_check="training_complete == True",
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
-    
+
     @staticmethod
     def convergence_cycle(
         workflow: Workflow,
         processor_node: str,
         tolerance: float = 0.001,
         max_iterations: int = 1000,
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add a numerical convergence cycle to workflow.
-        
+
         Creates a cycle that continues until successive iterations
         produce values within a specified tolerance.
-        
+
         Args:
             workflow: Target workflow
             processor_node: Node that produces values to check for convergence
             tolerance: Maximum difference between iterations for convergence
             max_iterations: Maximum iterations before forced termination
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("convergence", "Convergence Example")
             >>> workflow.add_node("processor", PythonCodeNode(), code="...")
@@ -482,11 +489,11 @@ result = {{
         """
         if cycle_id is None:
             cycle_id = f"convergence_cycle_{int(time.time())}"
-        
+
         # Create convergence checker node
         convergence_checker_id = f"{processor_node}_convergence_checker"
-        
-        convergence_code = f'''
+
+        convergence_code = f"""
 import math
 
 # Initialize convergence state
@@ -526,13 +533,16 @@ result = {{
 
 # Update for next iteration
 previous_value = current_value
-'''
-        
-        workflow.add_node(convergence_checker_id, PythonCodeNode(name=convergence_checker_id, code=convergence_code))
-        
+"""
+
+        workflow.add_node(
+            convergence_checker_id,
+            PythonCodeNode(name=convergence_checker_id, code=convergence_code),
+        )
+
         # Connect processor to convergence checker
         workflow.connect(processor_node, convergence_checker_id)
-        
+
         # Close the cycle with convergence condition
         workflow.connect(
             convergence_checker_id,
@@ -540,35 +550,35 @@ previous_value = current_value
             cycle=True,
             max_iterations=max_iterations,
             convergence_check="converged == True",
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
-    
+
     @staticmethod
     def batch_processing_cycle(
         workflow: Workflow,
         processor_node: str,
         batch_size: int = 100,
         total_items: Optional[int] = None,
-        cycle_id: Optional[str] = None
+        cycle_id: Optional[str] = None,
     ) -> str:
         """
         Add a batch processing cycle to workflow.
-        
+
         Creates a cycle that processes data in batches, continuing
         until all items are processed.
-        
+
         Args:
             workflow: Target workflow
             processor_node: Node that processes batches
             batch_size: Number of items to process per batch
             total_items: Total number of items to process (if known)
             cycle_id: Optional custom cycle identifier
-            
+
         Returns:
             str: The cycle identifier for reference
-            
+
         Example:
             >>> workflow = Workflow("batch", "Batch Processing Example")
             >>> workflow.add_node("processor", PythonCodeNode(), code="...")
@@ -578,11 +588,11 @@ previous_value = current_value
         """
         if cycle_id is None:
             cycle_id = f"batch_cycle_{int(time.time())}"
-        
+
         # Create batch controller node
         batch_controller_id = f"{processor_node}_batch_controller"
-        
-        batch_code = f'''
+
+        batch_code = f"""
 # Initialize batch state
 try:
     batch_number = batch_number
@@ -625,19 +635,22 @@ result = {{
 # Update for next iteration
 start_index = end_index
 items_processed += actual_batch_size
-'''
-        
-        workflow.add_node(batch_controller_id, PythonCodeNode(name=batch_controller_id, code=batch_code))
-        
+"""
+
+        workflow.add_node(
+            batch_controller_id,
+            PythonCodeNode(name=batch_controller_id, code=batch_code),
+        )
+
         # Connect batch controller to processor
         workflow.connect(batch_controller_id, processor_node)
-        
+
         # Calculate max iterations based on total items
         if total_items is not None:
             max_iterations = math.ceil(total_items / batch_size) + 1
         else:
             max_iterations = 1000  # Default upper bound
-        
+
         # Close the cycle with completion condition
         workflow.connect(
             processor_node,
@@ -645,9 +658,9 @@ items_processed += actual_batch_size
             cycle=True,
             max_iterations=max_iterations,
             convergence_check="all_processed == True",
-            cycle_id=cycle_id
+            cycle_id=cycle_id,
         )
-        
+
         return cycle_id
 
 
@@ -658,7 +671,7 @@ def add_optimization_cycle(
     evaluator_node: str,
     convergence: str = "quality > 0.9",
     max_iterations: int = 50,
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add an optimization cycle pattern to this workflow."""
     return CycleTemplates.optimization_cycle(
@@ -672,7 +685,7 @@ def add_retry_cycle(
     max_retries: int = 3,
     backoff_strategy: str = "exponential",
     success_condition: str = "success == True",
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add a retry cycle pattern to this workflow."""
     return CycleTemplates.retry_cycle(
@@ -686,7 +699,7 @@ def add_data_quality_cycle(
     validator_node: str,
     quality_threshold: float = 0.95,
     max_iterations: int = 10,
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add a data quality improvement cycle to this workflow."""
     return CycleTemplates.data_quality_cycle(
@@ -701,11 +714,17 @@ def add_learning_cycle(
     target_accuracy: float = 0.95,
     max_epochs: int = 100,
     early_stopping_patience: int = 10,
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add a machine learning training cycle to this workflow."""
     return CycleTemplates.learning_cycle(
-        self, trainer_node, evaluator_node, target_accuracy, max_epochs, early_stopping_patience, cycle_id
+        self,
+        trainer_node,
+        evaluator_node,
+        target_accuracy,
+        max_epochs,
+        early_stopping_patience,
+        cycle_id,
     )
 
 
@@ -714,7 +733,7 @@ def add_convergence_cycle(
     processor_node: str,
     tolerance: float = 0.001,
     max_iterations: int = 1000,
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add a numerical convergence cycle to this workflow."""
     return CycleTemplates.convergence_cycle(
@@ -727,7 +746,7 @@ def add_batch_processing_cycle(
     processor_node: str,
     batch_size: int = 100,
     total_items: Optional[int] = None,
-    cycle_id: Optional[str] = None
+    cycle_id: Optional[str] = None,
 ) -> str:
     """Add a batch processing cycle to this workflow."""
     return CycleTemplates.batch_processing_cycle(
@@ -741,4 +760,4 @@ Workflow.add_retry_cycle = add_retry_cycle
 Workflow.add_data_quality_cycle = add_data_quality_cycle
 Workflow.add_learning_cycle = add_learning_cycle
 Workflow.add_convergence_cycle = add_convergence_cycle
-Workflow.add_batch_processing_cycle = add_batch_processing_cycle
+Workflow.add_batch_processing_cycle = add_batch_processing_cycle