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

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 = []
 

kailash/workflow/cycle_exceptions.py

@@ -7,7 +7,7 @@ replace generic errors with detailed diagnostics to improve developer experience
 """
 
 import logging
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from kailash.sdk_exceptions import WorkflowException
 
@@ -55,9 +55,9 @@ class CycleException(WorkflowException):
         self,
         message: str,
         error_code: str = "CYCLE_ERROR",
-        context: Optional[Dict[str, Any]] = None,
-        suggestions: Optional[List[str]] = None,
-        documentation_url: Optional[str] = None,
+        context: dict[str, Any] | None = None,
+        suggestions: list[str] | None = None,
+        documentation_url: str | None = None,
     ):
         """
         Initialize cycle exception with enhanced error information.
@@ -148,8 +148,8 @@ class CycleConfigurationError(CycleException):
     def __init__(
         self,
         message: str,
-        cycle_id: Optional[str] = None,
-        invalid_params: Optional[Dict[str, Any]] = None,
+        cycle_id: str | None = None,
+        invalid_params: dict[str, Any] | None = None,
         **kwargs,
     ):
         """
@@ -216,10 +216,10 @@ class CycleConnectionError(CycleException):
     def __init__(
         self,
         message: str,
-        source_node: Optional[str] = None,
-        target_node: Optional[str] = None,
-        available_nodes: Optional[List[str]] = None,
-        mapping_errors: Optional[Dict[str, str]] = None,
+        source_node: str | None = None,
+        target_node: str | None = None,
+        available_nodes: list[str] | None = None,
+        mapping_errors: dict[str, str] | None = None,
         **kwargs,
     ):
         """
@@ -294,9 +294,9 @@ class CycleValidationError(CycleException):
     def __init__(
         self,
         message: str,
-        cycle_group: Optional[str] = None,
-        validation_failures: Optional[List[str]] = None,
-        conflicting_values: Optional[List[Any]] = None,
+        cycle_group: str | None = None,
+        validation_failures: list[str] | None = None,
+        conflicting_values: list[Any] | None = None,
         **kwargs,
     ):
         """
@@ -365,11 +365,11 @@ class CycleExecutionError(CycleException):
     def __init__(
         self,
         message: str,
-        cycle_id: Optional[str] = None,
-        current_iteration: Optional[int] = None,
-        max_iterations: Optional[int] = None,
-        timeout_seconds: Optional[float] = None,
-        memory_usage_mb: Optional[int] = None,
+        cycle_id: str | None = None,
+        current_iteration: int | None = None,
+        max_iterations: int | None = None,
+        timeout_seconds: float | None = None,
+        memory_usage_mb: int | None = None,
         **kwargs,
     ):
         """
@@ -465,10 +465,10 @@ class CycleConvergenceError(CycleException):
     def __init__(
         self,
         message: str,
-        convergence_expression: Optional[str] = None,
-        evaluation_error: Optional[str] = None,
-        available_variables: Optional[List[str]] = None,
-        cycle_data: Optional[Dict[str, Any]] = None,
+        convergence_expression: str | None = None,
+        evaluation_error: str | None = None,
+        available_variables: list[str] | None = None,
+        cycle_data: dict[str, Any] | None = None,
         **kwargs,
     ):
         """
@@ -523,7 +523,7 @@ class CycleConvergenceError(CycleException):
 
 # Utility functions for enhanced error reporting
 def create_configuration_error(
-    issue: str, cycle_id: Optional[str] = None, **invalid_params
+    issue: str, cycle_id: str | None = None, **invalid_params
 ) -> CycleConfigurationError:
     """
     Create a standardized configuration error with common suggestions.
@@ -550,9 +550,9 @@ def create_configuration_error(
 
 def create_connection_error(
     issue: str,
-    source_node: Optional[str] = None,
-    target_node: Optional[str] = None,
-    available_nodes: Optional[List[str]] = None,
+    source_node: str | None = None,
+    target_node: str | None = None,
+    available_nodes: list[str] | None = None,
 ) -> CycleConnectionError:
     """
     Create a standardized connection error with node context.
@@ -583,9 +583,9 @@ def create_connection_error(
 
 def create_execution_error(
     issue: str,
-    cycle_id: Optional[str] = None,
-    current_iteration: Optional[int] = None,
-    max_iterations: Optional[int] = None,
+    cycle_id: str | None = None,
+    current_iteration: int | None = None,
+    max_iterations: int | None = None,
 ) -> CycleExecutionError:
     """
     Create a standardized execution error with runtime context.

kailash/workflow/cycle_profiler.py

@@ -45,7 +45,7 @@ import logging
 import statistics
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from kailash.workflow.cycle_debugger import CycleExecutionTrace
 
@@ -83,13 +83,13 @@ class PerformanceMetrics:
     min_iteration_time: float = float("inf")
     max_iteration_time: float = 0.0
     iteration_time_stddev: float = 0.0
-    memory_stats: Dict[str, float] = field(default_factory=dict)
-    cpu_stats: Dict[str, float] = field(default_factory=dict)
-    convergence_stats: Dict[str, Any] = field(default_factory=dict)
-    bottlenecks: List[str] = field(default_factory=list)
-    optimization_opportunities: List[str] = field(default_factory=list)
+    memory_stats: dict[str, float] = field(default_factory=dict)
+    cpu_stats: dict[str, float] = field(default_factory=dict)
+    convergence_stats: dict[str, Any] = field(default_factory=dict)
+    bottlenecks: list[str] = field(default_factory=list)
+    optimization_opportunities: list[str] = field(default_factory=list)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert metrics to dictionary for serialization.
 
         Returns:
@@ -141,8 +141,8 @@ class CycleProfiler:
             enable_advanced_metrics: Whether to enable advanced statistical analysis.
         """
         self.enable_advanced_metrics = enable_advanced_metrics
-        self.traces: List[CycleExecutionTrace] = []
-        self.performance_history: List[PerformanceMetrics] = []
+        self.traces: list[CycleExecutionTrace] = []
+        self.performance_history: list[PerformanceMetrics] = []
 
     def add_trace(self, trace: CycleExecutionTrace):
         """
@@ -260,7 +260,7 @@ class CycleProfiler:
 
         return metrics
 
-    def compare_cycles(self, cycle_ids: List[str]) -> Dict[str, Any]:
+    def compare_cycles(self, cycle_ids: list[str]) -> dict[str, Any]:
         """
         Compare performance across multiple specific cycles.
 
@@ -338,8 +338,8 @@ class CycleProfiler:
         return comparison
 
     def get_optimization_recommendations(
-        self, trace: Optional[CycleExecutionTrace] = None
-    ) -> List[Dict[str, Any]]:
+        self, trace: CycleExecutionTrace | None = None
+    ) -> list[dict[str, Any]]:
         """
         Generate detailed optimization recommendations.
 
@@ -459,7 +459,7 @@ class CycleProfiler:
 
         return recommendations
 
-    def generate_performance_report(self) -> Dict[str, Any]:
+    def generate_performance_report(self) -> dict[str, Any]:
         """
         Generate comprehensive performance report.
 
@@ -560,8 +560,8 @@ class CycleProfiler:
         logger.info(f"Exported profiling data to {filepath} in {format} format")
 
     def _analyze_convergence_performance(
-        self, convergence_data: List[float]
-    ) -> Dict[str, Any]:
+        self, convergence_data: list[float]
+    ) -> dict[str, Any]:
         """Analyze convergence performance characteristics."""
         if not convergence_data:
             return {}
@@ -582,8 +582,8 @@ class CycleProfiler:
         }
 
     def _analyze_convergence_pattern(
-        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 for stability."""
         valid_points = [value for _, value in convergence_trend if value is not None]
 
@@ -608,7 +608,7 @@ class CycleProfiler:
             "reason": "high_volatility" if unstable else "stable",
         }
 
-    def _identify_bottlenecks(self, metrics: PerformanceMetrics) -> List[str]:
+    def _identify_bottlenecks(self, metrics: PerformanceMetrics) -> list[str]:
         """Identify performance bottlenecks from metrics."""
         bottlenecks = []
 
@@ -636,7 +636,7 @@ class CycleProfiler:
 
         return bottlenecks
 
-    def _identify_optimizations(self, metrics: PerformanceMetrics) -> List[str]:
+    def _identify_optimizations(self, metrics: PerformanceMetrics) -> list[str]:
         """Identify optimization opportunities."""
         optimizations = []
 
@@ -697,7 +697,7 @@ class CycleProfiler:
 
         return statistics.mean(score_components) if score_components else 0.5
 
-    def _analyze_performance_trends(self) -> Dict[str, Any]:
+    def _analyze_performance_trends(self) -> dict[str, Any]:
         """Analyze performance trends over time."""
         if len(self.performance_history) < 2:
             return {"trend": "insufficient_data"}
@@ -720,7 +720,7 @@ class CycleProfiler:
             "performance_history_length": len(self.performance_history),
         }
 
-    def _get_cycle_comparisons(self) -> Dict[str, Any]:
+    def _get_cycle_comparisons(self) -> dict[str, Any]:
         """Get comparative analysis across all cycles."""
         if len(self.traces) < 2:
             return {"comparison": "insufficient_data"}

kailash/workflow/cycle_state.py

@@ -2,8 +2,8 @@
 
 import logging
 import time
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from datetime import UTC, datetime
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -19,11 +19,11 @@ class CycleState:
         """
         self.cycle_id = cycle_id
         self.iteration = 0
-        self.history: List[Dict[str, Any]] = []
-        self.metadata: Dict[str, Any] = {}
+        self.history: list[dict[str, Any]] = []
+        self.metadata: dict[str, Any] = {}
         self.start_time = time.time()
         self.last_update_time = self.start_time
-        self.node_states: Dict[str, Any] = {}  # Per-node state storage
+        self.node_states: dict[str, Any] = {}  # Per-node state storage
 
     @property
     def elapsed_time(self) -> float:
@@ -35,7 +35,7 @@ class CycleState:
         """Get time since last iteration."""
         return time.time() - self.last_update_time
 
-    def update(self, results: Dict[str, Any], iteration: Optional[int] = None) -> None:
+    def update(self, results: dict[str, Any], iteration: int | None = None) -> None:
         """Update state with iteration results.
 
         Args:
@@ -51,7 +51,7 @@ class CycleState:
         history_entry = {
             "iteration": self.iteration,
             "results": results,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": datetime.now(UTC).isoformat(),
             "elapsed_time": self.elapsed_time,
             "iteration_time": self.iteration_time,
         }
@@ -90,7 +90,7 @@ class CycleState:
         """
         self.node_states[node_id] = state
 
-    def get_convergence_context(self) -> Dict[str, Any]:
+    def get_convergence_context(self) -> dict[str, Any]:
         """Get context for convergence evaluation.
 
         Returns:
@@ -110,7 +110,7 @@ class CycleState:
 
         return context
 
-    def calculate_trend(self) -> Dict[str, Any]:
+    def calculate_trend(self) -> dict[str, Any]:
         """Calculate trends from iteration history.
 
         Returns:
@@ -159,7 +159,7 @@ class CycleState:
 
         return trends
 
-    def _extract_numeric_keys(self, obj: Any, prefix: str = "") -> List[str]:
+    def _extract_numeric_keys(self, obj: Any, prefix: str = "") -> list[str]:
         """Extract all numeric value keys from nested dict."""
         keys = []
 
@@ -186,7 +186,7 @@ class CycleState:
 
         return value
 
-    def get_summary(self) -> Dict[str, Any]:
+    def get_summary(self) -> dict[str, Any]:
         """Get summary of cycle execution.
 
         Returns:
@@ -196,9 +196,7 @@ class CycleState:
             "cycle_id": self.cycle_id,
             "iterations": self.iteration,
             "elapsed_time": self.elapsed_time,
-            "start_time": datetime.fromtimestamp(
-                self.start_time, timezone.utc
-            ).isoformat(),
+            "start_time": datetime.fromtimestamp(self.start_time, UTC).isoformat(),
             "history_length": len(self.history),
         }
 
@@ -223,7 +221,7 @@ class CycleState:
 
         return summary
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Serialize state to dictionary.
 
         Returns:
@@ -240,7 +238,7 @@ class CycleState:
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "CycleState":
+    def from_dict(cls, data: dict[str, Any]) -> "CycleState":
         """Create CycleState from dictionary.
 
         Args:
@@ -264,8 +262,8 @@ class CycleStateManager:
 
     def __init__(self):
         """Initialize cycle state manager."""
-        self.states: Dict[str, CycleState] = {}
-        self.active_cycles: List[str] = []
+        self.states: dict[str, CycleState] = {}
+        self.active_cycles: list[str] = []
 
     def get_or_create_state(self, cycle_id: str) -> CycleState:
         """Get existing state or create new one.
@@ -291,7 +289,7 @@ class CycleStateManager:
         self.active_cycles.append(cycle_id)
         logger.debug(f"Pushed cycle: {cycle_id}, stack: {self.active_cycles}")
 
-    def pop_cycle(self) -> Optional[str]:
+    def pop_cycle(self) -> str | None:
         """Pop cycle from active stack.
 
         Returns:
@@ -303,7 +301,7 @@ class CycleStateManager:
             return cycle_id
         return None
 
-    def get_active_cycle(self) -> Optional[str]:
+    def get_active_cycle(self) -> str | None:
         """Get currently active cycle ID.
 
         Returns:
@@ -311,7 +309,7 @@ class CycleStateManager:
         """
         return self.active_cycles[-1] if self.active_cycles else None
 
-    def get_all_summaries(self) -> Dict[str, Dict[str, Any]]:
+    def get_all_summaries(self) -> dict[str, dict[str, Any]]:
         """Get summaries for all cycles.
 
         Returns:
@@ -321,7 +319,7 @@ class CycleStateManager:
             cycle_id: state.get_summary() for cycle_id, state in self.states.items()
         }
 
-    def clear(self, cycle_id: Optional[str] = None) -> None:
+    def clear(self, cycle_id: str | None = None) -> None:
         """Clear cycle state(s).
 
         Args: