kailash 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

kailash/workflow/convergence.py

@@ -2,7 +2,8 @@
 
 import logging
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from kailash.workflow.cycle_state import CycleState
@@ -14,7 +15,7 @@ class ConvergenceCondition(ABC):
     """Base class for cycle convergence conditions."""
 
     @abstractmethod
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Evaluate if cycle should terminate.
 
         Args:
@@ -48,7 +49,7 @@ class ExpressionCondition(ConvergenceCondition):
         """
         self.expression = expression
 
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Evaluate expression with results and cycle state context."""
         # Create evaluation context
         context = {
@@ -117,8 +118,8 @@ class CallbackCondition(ConvergenceCondition):
 
     def __init__(
         self,
-        callback: Callable[[Dict[str, Any], "CycleState"], bool],
-        name: Optional[str] = None,
+        callback: Callable[[dict[str, Any], "CycleState"], bool],
+        name: str | None = None,
     ):
         """Initialize with callback function.
 
@@ -129,7 +130,7 @@ class CallbackCondition(ConvergenceCondition):
         self.callback = callback
         self.name = name or callback.__name__
 
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Evaluate callback with results and cycle state."""
         try:
             return self.callback(results, cycle_state)
@@ -154,7 +155,7 @@ class MaxIterationsCondition(ConvergenceCondition):
         """
         self.max_iterations = max_iterations
 
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Check if maximum iterations reached."""
         return cycle_state.iteration >= self.max_iterations
 
@@ -166,7 +167,7 @@ class MaxIterationsCondition(ConvergenceCondition):
 class CompoundCondition(ConvergenceCondition):
     """Combine multiple conditions with AND/OR logic."""
 
-    def __init__(self, conditions: List[ConvergenceCondition], operator: str = "OR"):
+    def __init__(self, conditions: list[ConvergenceCondition], operator: str = "OR"):
         """Initialize with list of conditions.
 
         Args:
@@ -178,7 +179,7 @@ class CompoundCondition(ConvergenceCondition):
         if self.operator not in ["AND", "OR"]:
             raise ValueError("Operator must be 'AND' or 'OR'")
 
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Evaluate all conditions with specified operator."""
         evaluations = [cond.evaluate(results, cycle_state) for cond in self.conditions]
 
@@ -196,7 +197,7 @@ class CompoundCondition(ConvergenceCondition):
 class AdaptiveCondition(ConvergenceCondition):
     """Adaptive convergence that changes based on iteration progress."""
 
-    def __init__(self, stages: List[tuple[int, ConvergenceCondition]]):
+    def __init__(self, stages: list[tuple[int, ConvergenceCondition]]):
         """Initialize with stages of conditions.
 
         Args:
@@ -205,7 +206,7 @@ class AdaptiveCondition(ConvergenceCondition):
         """
         self.stages = sorted(stages, key=lambda x: x[0])
 
-    def evaluate(self, results: Dict[str, Any], cycle_state: "CycleState") -> bool:
+    def evaluate(self, results: dict[str, Any], cycle_state: "CycleState") -> bool:
         """Evaluate condition based on current iteration stage."""
         current_iteration = cycle_state.iteration
 
@@ -229,7 +230,7 @@ class AdaptiveCondition(ConvergenceCondition):
 
 
 def create_convergence_condition(
-    spec: Union[str, int, Callable, Dict],
+    spec: str | int | Callable | dict,
 ) -> ConvergenceCondition:
     """Factory function to create convergence conditions from various specs.
 

kailash/workflow/cycle_analyzer.py

@@ -36,7 +36,7 @@ import json
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from kailash.workflow.cycle_debugger import CycleDebugger, CycleExecutionTrace
 from kailash.workflow.cycle_profiler import CycleProfiler
@@ -70,7 +70,7 @@ class CycleAnalyzer:
         analysis_level: str = "standard",
         enable_profiling: bool = True,
         enable_debugging: bool = True,
-        output_directory: Optional[str] = None,
+        output_directory: str | None = None,
     ):
         """
         Initialize cycle analyzer.
@@ -113,9 +113,9 @@ class CycleAnalyzer:
         )
 
         # Analysis session tracking
-        self.current_session: Optional[str] = None
-        self.session_traces: List[CycleExecutionTrace] = []
-        self.analysis_history: List[Dict[str, Any]] = []
+        self.current_session: str | None = None
+        self.session_traces: list[CycleExecutionTrace] = []
+        self.analysis_history: list[dict[str, Any]] = []
 
         # Create output directory if specified
         if self.output_directory:
@@ -149,10 +149,10 @@ class CycleAnalyzer:
         self,
         cycle_id: str,
         workflow_id: str,
-        max_iterations: Optional[int] = None,
-        timeout: Optional[float] = None,
-        convergence_condition: Optional[str] = None,
-    ) -> Optional[CycleExecutionTrace]:
+        max_iterations: int | None = None,
+        timeout: float | None = None,
+        convergence_condition: str | None = None,
+    ) -> CycleExecutionTrace | None:
         """
         Start analysis for a new cycle execution.
 
@@ -193,10 +193,10 @@ class CycleAnalyzer:
     def track_iteration(
         self,
         trace: CycleExecutionTrace,
-        input_data: Dict[str, Any],
-        output_data: Dict[str, Any],
-        convergence_value: Optional[float] = None,
-        node_executions: Optional[List[str]] = None,
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        convergence_value: float | None = None,
+        node_executions: list[str] | None = None,
     ):
         """
         Track a single cycle iteration with input/output data.
@@ -234,7 +234,7 @@ class CycleAnalyzer:
         trace: CycleExecutionTrace,
         converged: bool,
         termination_reason: str,
-        convergence_iteration: Optional[int] = None,
+        convergence_iteration: int | None = None,
     ):
         """
         Complete cycle analysis and generate insights.
@@ -276,7 +276,7 @@ class CycleAnalyzer:
         if self.analysis_level == "comprehensive":
             self._generate_immediate_insights(trace)
 
-    def generate_cycle_report(self, trace: CycleExecutionTrace) -> Dict[str, Any]:
+    def generate_cycle_report(self, trace: CycleExecutionTrace) -> dict[str, Any]:
         """
         Generate comprehensive report for a single cycle.
 
@@ -333,9 +333,7 @@ class CycleAnalyzer:
 
         return report
 
-    def generate_session_report(
-        self, session_id: Optional[str] = None
-    ) -> Dict[str, Any]:
+    def generate_session_report(self, session_id: str | None = None) -> dict[str, Any]:
         """
         Generate comprehensive report for an analysis session.
 
@@ -414,7 +412,7 @@ class CycleAnalyzer:
 
         return report
 
-    def get_real_time_metrics(self, trace: CycleExecutionTrace) -> Dict[str, Any]:
+    def get_real_time_metrics(self, trace: CycleExecutionTrace) -> dict[str, Any]:
         """
         Get real-time metrics for an active cycle.
 
@@ -487,7 +485,7 @@ class CycleAnalyzer:
 
     def export_analysis_data(
         self,
-        filepath: Optional[str] = None,
+        filepath: str | None = None,
         format: str = "json",
         include_traces: bool = True,
     ):
@@ -605,7 +603,7 @@ class CycleAnalyzer:
                 f"Slow iterations detected for cycle '{trace.cycle_id}' - avg: {stats['avg_iteration_time']:.3f}s"
             )
 
-    def _generate_advanced_analysis(self, trace: CycleExecutionTrace) -> Dict[str, Any]:
+    def _generate_advanced_analysis(self, trace: CycleExecutionTrace) -> dict[str, Any]:
         """Generate advanced analysis insights for comprehensive mode."""
         convergence_trend = trace.get_convergence_trend()
 
@@ -657,8 +655,8 @@ class CycleAnalyzer:
         }
 
     def _generate_session_insights(
-        self, traces: List[CycleExecutionTrace]
-    ) -> Dict[str, Any]:
+        self, traces: list[CycleExecutionTrace]
+    ) -> dict[str, Any]:
         """Generate insights across multiple cycles in a session."""
         if not traces:
             return {}
@@ -692,7 +690,7 @@ class CycleAnalyzer:
         return insights
 
     def _calculate_real_time_health_score(
-        self, trace: CycleExecutionTrace, recent_iterations: List
+        self, trace: CycleExecutionTrace, recent_iterations: list
     ) -> float:
         """Calculate real-time health score for an active cycle."""
         score_components = []
@@ -732,8 +730,8 @@ class CycleAnalyzer:
         )
 
     def _generate_real_time_alerts(
-        self, trace: CycleExecutionTrace, recent_iterations: List
-    ) -> List[str]:
+        self, trace: CycleExecutionTrace, recent_iterations: list
+    ) -> list[str]:
         """Generate real-time alerts for potential issues."""
         alerts = []
 
@@ -771,7 +769,7 @@ class CycleAnalyzer:
 
         return alerts
 
-    def _calculate_convergence_stability(self, values: List[float]) -> float:
+    def _calculate_convergence_stability(self, values: list[float]) -> float:
         """Calculate stability score for convergence values."""
         if len(values) < 2:
             return 1.0
@@ -788,7 +786,7 @@ class CycleAnalyzer:
         # Lower CV means more stable
         return max(0.0, 1.0 - min(1.0, cv))
 
-    def _calculate_skewness(self, data: List[float]) -> float:
+    def _calculate_skewness(self, data: list[float]) -> float:
         """Calculate skewness of data distribution."""
         if len(data) < 3:
             return 0.0
@@ -805,7 +803,7 @@ class CycleAnalyzer:
         skewness = sum((x - mean_val) ** 3 for x in data) / (n * std_dev**3)
         return skewness
 
-    def _analyze_performance_trend(self, iteration_times: List[float]) -> str:
+    def _analyze_performance_trend(self, iteration_times: list[float]) -> str:
         """Analyze performance trend over iterations."""
         if len(iteration_times) < 3:
             return "insufficient_data"
@@ -830,7 +828,7 @@ class CycleAnalyzer:
 
     def _analyze_resource_efficiency(
         self, trace: CycleExecutionTrace
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Analyze resource usage efficiency."""
         memory_values = [
             iter.memory_usage_mb for iter in trace.iterations if iter.memory_usage_mb
@@ -867,7 +865,7 @@ class CycleAnalyzer:
 
         return efficiency
 
-    def _export_cycle_report(self, report: Dict[str, Any], cycle_id: str):
+    def _export_cycle_report(self, report: dict[str, Any], cycle_id: str):
         """Export cycle report to file."""
         if not self.output_directory:
             return
@@ -882,7 +880,7 @@ class CycleAnalyzer:
 
         logger.debug(f"Exported cycle report to {filepath}")
 
-    def _export_session_report(self, report: Dict[str, Any], session_id: str):
+    def _export_session_report(self, report: dict[str, Any], session_id: str):
         """Export session report to file."""
         if not self.output_directory:
             return

kailash/workflow/cycle_builder.py

@@ -40,7 +40,7 @@ Examples:
 """
 
 import logging
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING
 
 from kailash.sdk_exceptions import WorkflowValidationError
 from kailash.workflow.cycle_exceptions import (
@@ -75,7 +75,7 @@ class CycleBuilder:
         ...      .build()
     """
 
-    def __init__(self, workflow: "Workflow", cycle_id: Optional[str] = None):
+    def __init__(self, workflow: "Workflow", cycle_id: str | None = None):
         """
         Initialize a new CycleBuilder.
 
@@ -87,23 +87,23 @@ class CycleBuilder:
         self._cycle_id = cycle_id
 
         # Connection parameters
-        self._source_node: Optional[str] = None
-        self._target_node: Optional[str] = None
-        self._mapping: Optional[Dict[str, str]] = None
+        self._source_node: str | None = None
+        self._target_node: str | None = None
+        self._mapping: dict[str, str] | None = None
 
         # Cycle parameters
-        self._max_iterations: Optional[int] = None
-        self._convergence_check: Optional[str] = None
-        self._timeout: Optional[float] = None
-        self._memory_limit: Optional[int] = None
-        self._condition: Optional[str] = None
-        self._parent_cycle: Optional[str] = None
+        self._max_iterations: int | None = None
+        self._convergence_check: str | None = None
+        self._timeout: float | None = None
+        self._memory_limit: int | None = None
+        self._condition: str | None = None
+        self._parent_cycle: str | None = None
 
     def connect(
         self,
         source_node: str,
         target_node: str,
-        mapping: Optional[Dict[str, str]] = None,
+        mapping: dict[str, str] | None = None,
     ) -> "CycleBuilder":
         """
         Configure the source and target nodes for the cycle connection.

kailash/workflow/cycle_config.py

@@ -93,8 +93,9 @@ See Also:
 """
 
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any
 
 from kailash.workflow.cycle_exceptions import CycleConfigurationError
 
@@ -150,26 +151,26 @@ class CycleConfig:
     """
 
     # Termination conditions (at least one required)
-    max_iterations: Optional[int] = None
-    convergence_check: Optional[Union[str, Callable]] = None
-    timeout: Optional[float] = None
+    max_iterations: int | None = None
+    convergence_check: str | Callable | None = None
+    timeout: float | None = None
 
     # Safety and resource limits
-    memory_limit: Optional[int] = None
+    memory_limit: int | None = None
     iteration_safety_factor: float = 1.5  # Multiplier for max_iterations safety
 
     # Cycle metadata and identification
-    cycle_id: Optional[str] = None
-    parent_cycle: Optional[str] = None
+    cycle_id: str | None = None
+    parent_cycle: str | None = None
     description: str = ""
 
     # Execution control and conditions
-    condition: Optional[str] = None  # When to execute the cycle
+    condition: str | None = 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)
+    retry_policy: dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self):
         """
@@ -378,7 +379,7 @@ class CycleConfig:
                 ],
             )
 
-    def get_effective_max_iterations(self) -> Optional[int]:
+    def get_effective_max_iterations(self) -> int | None:
         """
         Get the effective maximum iterations with safety factor applied.
 
@@ -401,7 +402,7 @@ class CycleConfig:
             return None
         return int(self.max_iterations * self.iteration_safety_factor)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Convert configuration to dictionary format.
 
@@ -433,7 +434,7 @@ class CycleConfig:
         return result
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "CycleConfig":
+    def from_dict(cls, data: dict[str, Any]) -> "CycleConfig":
         """
         Create configuration from dictionary data.
 
@@ -508,7 +509,7 @@ class CycleConfig:
 
         return CycleConfig(**merged_data)
 
-    def create_template(self, template_name: str) -> Dict[str, Any]:
+    def create_template(self, template_name: str) -> dict[str, Any]:
         """
         Create a reusable template from this configuration.
 
@@ -600,7 +601,7 @@ class CycleTemplates:
     def optimization_loop(
         max_iterations: int = 100,
         convergence_threshold: float = 0.01,
-        timeout: Optional[float] = None,
+        timeout: float | None = None,
     ) -> CycleConfig:
         """
         Create configuration for optimization cycles.

kailash/workflow/cycle_debugger.py

@@ -49,7 +49,7 @@ import json
 import logging
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -79,18 +79,18 @@ class CycleIteration:
 
     iteration_number: int
     start_time: datetime
-    end_time: Optional[datetime] = None
-    execution_time: Optional[float] = None
-    input_data: Dict[str, Any] = field(default_factory=dict)
-    output_data: Optional[Dict[str, Any]] = None
-    memory_usage_mb: Optional[float] = None
-    cpu_usage_percent: Optional[float] = None
-    convergence_value: Optional[float] = None
-    error: Optional[str] = None
-    node_executions: List[str] = field(default_factory=list)
+    end_time: datetime | None = None
+    execution_time: float | None = None
+    input_data: dict[str, Any] = field(default_factory=dict)
+    output_data: dict[str, Any] | None = None
+    memory_usage_mb: float | None = None
+    cpu_usage_percent: float | None = None
+    convergence_value: float | None = None
+    error: str | None = None
+    node_executions: list[str] = field(default_factory=list)
 
     def complete(
-        self, output_data: Dict[str, Any], convergence_value: Optional[float] = None
+        self, output_data: dict[str, Any], convergence_value: float | None = None
     ):
         """
         Mark iteration as complete with output data.
@@ -131,7 +131,7 @@ class CycleIteration:
         """
         return self.end_time is not None and self.error is None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert iteration to dictionary for serialization.
 
         Returns:
@@ -179,17 +179,17 @@ class CycleExecutionTrace:
     cycle_id: str
     workflow_id: str
     start_time: datetime
-    end_time: Optional[datetime] = None
-    total_execution_time: Optional[float] = None
-    iterations: List[CycleIteration] = field(default_factory=list)
+    end_time: datetime | None = None
+    total_execution_time: float | None = None
+    iterations: list[CycleIteration] = field(default_factory=list)
     converged: bool = False
-    convergence_iteration: Optional[int] = None
+    convergence_iteration: int | None = None
     termination_reason: str = "unknown"
-    max_iterations_configured: Optional[int] = None
-    timeout_configured: Optional[float] = None
-    convergence_condition: Optional[str] = None
-    memory_peak_mb: Optional[float] = None
-    cpu_peak_percent: Optional[float] = None
+    max_iterations_configured: int | None = None
+    timeout_configured: float | None = None
+    convergence_condition: str | None = None
+    memory_peak_mb: float | None = None
+    cpu_peak_percent: float | None = None
 
     def add_iteration(self, iteration: CycleIteration):
         """
@@ -216,7 +216,7 @@ class CycleExecutionTrace:
         self,
         converged: bool,
         termination_reason: str,
-        convergence_iteration: Optional[int] = None,
+        convergence_iteration: int | None = None,
     ):
         """
         Mark cycle execution as complete.
@@ -232,7 +232,7 @@ class CycleExecutionTrace:
         self.termination_reason = termination_reason
         self.convergence_iteration = convergence_iteration
 
-    def get_statistics(self) -> Dict[str, Any]:
+    def get_statistics(self) -> dict[str, Any]:
         """
         Get comprehensive statistics about the cycle execution.
 
@@ -316,7 +316,7 @@ class CycleExecutionTrace:
 
         return stats
 
-    def get_convergence_trend(self) -> List[Tuple[int, Optional[float]]]:
+    def get_convergence_trend(self) -> list[tuple[int, float | None]]:
         """
         Get convergence values over iterations for trend analysis.
 
@@ -335,7 +335,7 @@ class CycleExecutionTrace:
             (iter.iteration_number, iter.convergence_value) for iter in self.iterations
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert trace to dictionary for serialization."""
         return {
             "cycle_id": self.cycle_id,
@@ -411,7 +411,7 @@ class CycleDebugger:
         """
         self.debug_level = debug_level
         self.enable_profiling = enable_profiling
-        self.active_traces: Dict[str, CycleExecutionTrace] = {}
+        self.active_traces: dict[str, CycleExecutionTrace] = {}
 
         # Configure logging based on debug level
         if debug_level == "verbose":
@@ -425,9 +425,9 @@ class CycleDebugger:
         self,
         cycle_id: str,
         workflow_id: str,
-        max_iterations: Optional[int] = None,
-        timeout: Optional[float] = None,
-        convergence_condition: Optional[str] = None,
+        max_iterations: int | None = None,
+        timeout: float | None = None,
+        convergence_condition: str | None = None,
     ) -> CycleExecutionTrace:
         """
         Start debugging a new cycle execution.
@@ -473,8 +473,8 @@ class CycleDebugger:
     def start_iteration(
         self,
         trace: CycleExecutionTrace,
-        input_data: Dict[str, Any],
-        iteration_number: Optional[int] = None,
+        input_data: dict[str, Any],
+        iteration_number: int | None = None,
     ) -> CycleIteration:
         """
         Start debugging a new cycle iteration.
@@ -533,9 +533,9 @@ class CycleDebugger:
         self,
         trace: CycleExecutionTrace,
         iteration: CycleIteration,
-        output_data: Dict[str, Any],
-        convergence_value: Optional[float] = None,
-        node_executions: Optional[List[str]] = None,
+        output_data: dict[str, Any],
+        convergence_value: float | None = None,
+        node_executions: list[str] | None = None,
     ):
         """
         Complete iteration tracking with output data and metrics.
@@ -598,7 +598,7 @@ class CycleDebugger:
         trace: CycleExecutionTrace,
         converged: bool,
         termination_reason: str,
-        convergence_iteration: Optional[int] = None,
+        convergence_iteration: int | None = None,
     ):
         """
         Complete cycle tracking with final results and analysis.
@@ -632,7 +632,7 @@ class CycleDebugger:
             f"converged={converged}, efficiency={stats['efficiency_score']:.2f}"
         )
 
-    def generate_report(self, trace: CycleExecutionTrace) -> Dict[str, Any]:
+    def generate_report(self, trace: CycleExecutionTrace) -> dict[str, Any]:
         """
         Generate comprehensive debugging report for a cycle execution.
 
@@ -691,8 +691,8 @@ class CycleDebugger:
         return report
 
     def _analyze_convergence(
-        self, convergence_trend: List[Tuple[int, Optional[float]]]
-    ) -> Dict[str, Any]:
+        self, convergence_trend: list[tuple[int, float | None]]
+    ) -> dict[str, Any]:
         """Analyze convergence pattern from trend data."""
         if not convergence_trend or all(
             value is None for _, value in convergence_trend
@@ -748,8 +748,8 @@ class CycleDebugger:
         }
 
     def _generate_recommendations(
-        self, trace: CycleExecutionTrace, stats: Dict[str, Any]
-    ) -> List[str]:
+        self, trace: CycleExecutionTrace, stats: dict[str, Any]
+    ) -> list[str]:
         """Generate optimization recommendations based on execution analysis."""
         recommendations = []