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

kailash/workflow/cycle_config.py

@@ -48,7 +48,7 @@ Template System:
 
 Example Usage:
     Basic configuration:
-    
+
     >>> from kailash.workflow.cycle_config import CycleConfig
     >>> config = CycleConfig(
     ...     max_iterations=100,
@@ -61,9 +61,9 @@ Example Usage:
     ...     "processor", "evaluator",
     ...     cycle=True, cycle_config=config
     ... )
-    
+
     Template usage:
-    
+
     >>> from kailash.workflow.cycle_config import CycleTemplates
     >>> # Pre-optimized configuration
     >>> config = CycleTemplates.optimization_loop(
@@ -75,9 +75,9 @@ Example Usage:
     ...     timeout=600.0,
     ...     memory_limit=2048
     ... ))
-    
+
     Configuration management:
-    
+
     >>> # Export for reuse
     >>> template_data = config.create_template("ml_training")
     >>> # Import and modify
@@ -136,7 +136,7 @@ class CycleConfig:
         >>> # Basic configuration
         >>> config = CycleConfig(max_iterations=100, convergence_check="error < 0.01")
         >>> workflow.connect("a", "b", cycle_config=config)
-        
+
         >>> # Advanced configuration with all features
         >>> config = CycleConfig(
         ...     max_iterations=50,
@@ -166,7 +166,7 @@ class CycleConfig:
     # Execution control and conditions
     condition: Optional[str] = None  # When to execute the cycle
     priority: int = 0  # Execution priority for multiple cycles
-    
+
     # Advanced configuration
     retry_policy: Dict[str, Any] = field(default_factory=dict)
     metadata: Dict[str, Any] = field(default_factory=dict)
@@ -214,9 +214,9 @@ class CycleConfig:
         termination_conditions = [
             self.max_iterations is not None,
             self.convergence_check is not None,
-            self.timeout is not None
+            self.timeout is not None,
         ]
-        
+
         if not any(termination_conditions):
             errors.append(
                 "At least one termination condition is required: "
@@ -233,8 +233,8 @@ class CycleConfig:
                     invalid_params={"max_iterations": self.max_iterations},
                     suggestions=[
                         "Use integer values for max_iterations",
-                        "Convert float values to int if needed"
-                    ]
+                        "Convert float values to int if needed",
+                    ],
                 )
             elif self.max_iterations <= 0:
                 raise CycleConfigurationError(
@@ -244,8 +244,8 @@ class CycleConfig:
                     suggestions=[
                         "Use 10-100 iterations for quick convergence",
                         "Use 100-1000 iterations for complex optimization",
-                        "Consider adding convergence_check for early termination"
-                    ]
+                        "Consider adding convergence_check for early termination",
+                    ],
                 )
             elif self.max_iterations > 10000:
                 warnings.append(
@@ -263,7 +263,14 @@ class CycleConfig:
                     )
                 else:
                     # Validate expression safety
-                    unsafe_patterns = ['import ', 'exec(', 'eval(', '__', 'open(', 'file(']
+                    unsafe_patterns = [
+                        "import ",
+                        "exec(",
+                        "eval(",
+                        "__",
+                        "open(",
+                        "file(",
+                    ]
                     for pattern in unsafe_patterns:
                         if pattern in self.convergence_check:
                             errors.append(
@@ -293,7 +300,9 @@ class CycleConfig:
         # Validate memory_limit
         if self.memory_limit is not None:
             if not isinstance(self.memory_limit, int):
-                errors.append(f"memory_limit must be an integer, got {type(self.memory_limit)}")
+                errors.append(
+                    f"memory_limit must be an integer, got {type(self.memory_limit)}"
+                )
             elif self.memory_limit <= 0:
                 errors.append(
                     f"memory_limit must be positive, got {self.memory_limit}. "
@@ -307,7 +316,9 @@ class CycleConfig:
 
         # Validate iteration_safety_factor
         if not isinstance(self.iteration_safety_factor, (int, float)):
-            errors.append(f"iteration_safety_factor must be numeric, got {type(self.iteration_safety_factor)}")
+            errors.append(
+                f"iteration_safety_factor must be numeric, got {type(self.iteration_safety_factor)}"
+            )
         elif self.iteration_safety_factor < 1.0:
             errors.append(
                 f"iteration_safety_factor must be >= 1.0, got {self.iteration_safety_factor}. "
@@ -353,7 +364,9 @@ class CycleConfig:
 
         # Raise errors if any found
         if errors:
-            error_message = "CycleConfig validation failed:\n" + "\n".join(f"• {error}" for error in errors)
+            error_message = "CycleConfig validation failed:\n" + "\n".join(
+                f"• {error}" for error in errors
+            )
             raise CycleConfigurationError(
                 error_message,
                 error_code="CYCLE_CONFIG_001",
@@ -361,8 +374,8 @@ class CycleConfig:
                     "Ensure at least one termination condition (max_iterations, convergence_check, or timeout)",
                     "Use positive values for numeric parameters",
                     "Avoid unsafe operations in convergence expressions",
-                    "Check the CycleConfig documentation for valid parameter ranges"
-                ]
+                    "Check the CycleConfig documentation for valid parameter ranges",
+                ],
             )
 
     def get_effective_max_iterations(self) -> Optional[int]:
@@ -408,15 +421,15 @@ class CycleConfig:
             {'max_iterations': 100, 'iteration_safety_factor': 1.5, ...}
         """
         result = {}
-        
+
         for key, value in self.__dict__.items():
             if value is not None:
                 # Skip callable convergence_check for serialization
-                if key == 'convergence_check' and callable(value):
-                    result[key] = '<callable>'
+                if key == "convergence_check" and callable(value):
+                    result[key] = "<callable>"
                 else:
                     result[key] = value
-        
+
         return result
 
     @classmethod
@@ -447,11 +460,13 @@ class CycleConfig:
         # Filter out unknown fields
         known_fields = {f.name for f in cls.__dataclass_fields__.values()}
         filtered_data = {k: v for k, v in data.items() if k in known_fields}
-        
+
         try:
             return cls(**filtered_data)
         except Exception as e:
-            raise CycleConfigurationError(f"Failed to create CycleConfig from data: {e}") from e
+            raise CycleConfigurationError(
+                f"Failed to create CycleConfig from data: {e}"
+            ) from e
 
     def merge(self, other: "CycleConfig") -> "CycleConfig":
         """
@@ -480,17 +495,17 @@ class CycleConfig:
             >>> # Result has max_iterations=100, timeout=60.0, cycle_id="custom"
         """
         merged_data = {}
-        
+
         # Start with this configuration
         for key, value in self.__dict__.items():
             if value is not None:
                 merged_data[key] = value
-        
+
         # Override with other configuration
         for key, value in other.__dict__.items():
             if value is not None:
                 merged_data[key] = value
-        
+
         return CycleConfig(**merged_data)
 
     def create_template(self, template_name: str) -> Dict[str, Any]:
@@ -522,10 +537,10 @@ class CycleConfig:
             "usage_notes": {
                 "max_iterations": "Adjust based on expected convergence time",
                 "convergence_check": "Modify condition for your specific metrics",
-                "timeout": "Set based on acceptable execution time"
-            }
+                "timeout": "Set based on acceptable execution time",
+            },
         }
-        
+
         return template_data
 
     def __repr__(self) -> str:
@@ -541,17 +556,21 @@ class CycleConfig:
             'CycleConfig(max_iterations=100, timeout=60.0, cycle_id=None)'
         """
         key_params = []
-        
+
         if self.max_iterations is not None:
             key_params.append(f"max_iterations={self.max_iterations}")
         if self.convergence_check is not None:
-            conv_str = self.convergence_check if isinstance(self.convergence_check, str) else "<callable>"
+            conv_str = (
+                self.convergence_check
+                if isinstance(self.convergence_check, str)
+                else "<callable>"
+            )
             key_params.append(f"convergence_check='{conv_str}'")
         if self.timeout is not None:
             key_params.append(f"timeout={self.timeout}")
         if self.cycle_id is not None:
             key_params.append(f"cycle_id='{self.cycle_id}'")
-        
+
         return f"CycleConfig({', '.join(key_params)})"
 
 
@@ -572,7 +591,7 @@ class CycleTemplates:
     Example:
         >>> # Quick optimization cycle
         >>> config = CycleTemplates.optimization_loop(max_iterations=50)
-        
+
         >>> # Retry logic with exponential backoff
         >>> config = CycleTemplates.retry_cycle(max_retries=3)
     """
@@ -581,7 +600,7 @@ class CycleTemplates:
     def optimization_loop(
         max_iterations: int = 100,
         convergence_threshold: float = 0.01,
-        timeout: Optional[float] = None
+        timeout: Optional[float] = None,
     ) -> CycleConfig:
         """
         Create configuration for optimization cycles.
@@ -608,13 +627,12 @@ class CycleTemplates:
             timeout=timeout,
             cycle_id="optimization_loop",
             description="Iterative optimization cycle with convergence detection",
-            iteration_safety_factor=2.0  # Higher safety for optimization
+            iteration_safety_factor=2.0,  # Higher safety for optimization
         )
 
     @staticmethod
     def retry_cycle(
-        max_retries: int = 3,
-        timeout_per_retry: float = 30.0
+        max_retries: int = 3, timeout_per_retry: float = 30.0
     ) -> CycleConfig:
         """
         Create configuration for retry logic patterns.
@@ -640,13 +658,12 @@ class CycleTemplates:
             cycle_id="retry_cycle",
             description="Retry cycle with exponential backoff support",
             condition="error_occurred == True",
-            iteration_safety_factor=1.2  # Conservative safety for retries
+            iteration_safety_factor=1.2,  # Conservative safety for retries
         )
 
     @staticmethod
     def data_quality_cycle(
-        quality_threshold: float = 0.95,
-        max_iterations: int = 10
+        quality_threshold: float = 0.95, max_iterations: int = 10
     ) -> CycleConfig:
         """
         Create configuration for data quality improvement cycles.
@@ -677,8 +694,7 @@ class CycleTemplates:
 
     @staticmethod
     def training_loop(
-        max_epochs: int = 100,
-        early_stopping_patience: int = 10
+        max_epochs: int = 100, early_stopping_patience: int = 10
     ) -> CycleConfig:
         """
         Create configuration for machine learning training cycles.
@@ -705,5 +721,5 @@ class CycleTemplates:
             cycle_id="training_loop",
             description="ML training cycle with early stopping",
             memory_limit=8192,  # 8GB for ML training
-            iteration_safety_factor=1.1  # Conservative for long training
-        )
+            iteration_safety_factor=1.1,  # Conservative for long training
+        )