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

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:

kailash/workflow/cyclic_runner.py

@@ -99,8 +99,8 @@ See Also:
 """
 
 import logging
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Set, Tuple
+from datetime import UTC, datetime
+from typing import Any, Optional
 
 import networkx as nx
 
@@ -127,15 +127,15 @@ class WorkflowState:
             run_id: Unique execution run ID
         """
         self.run_id = run_id
-        self.node_outputs: Dict[str, Any] = {}
-        self.execution_order: List[str] = []
-        self.metadata: Dict[str, Any] = {}
+        self.node_outputs: dict[str, Any] = {}
+        self.execution_order: list[str] = []
+        self.metadata: dict[str, Any] = {}
 
 
 class CyclicWorkflowExecutor:
     """Execution engine supporting cyclic workflows with fixed parameter propagation."""
 
-    def __init__(self, safety_manager: Optional[CycleSafetyManager] = None):
+    def __init__(self, safety_manager: CycleSafetyManager | None = None):
         """Initialize cyclic workflow executor.
 
         Args:
@@ -148,10 +148,10 @@ class CyclicWorkflowExecutor:
     def execute(
         self,
         workflow: Workflow,
-        parameters: Optional[Dict[str, Any]] = None,
-        task_manager: Optional[TaskManager] = None,
-        run_id: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], str]:
+        parameters: dict[str, Any] | None = None,
+        task_manager: TaskManager | None = None,
+        run_id: str | None = None,
+    ) -> tuple[dict[str, Any], str]:
         """Execute workflow with cycle support.
 
         Args:
@@ -223,10 +223,10 @@ class CyclicWorkflowExecutor:
     def _execute_with_cycles(
         self,
         workflow: Workflow,
-        parameters: Optional[Dict[str, Any]],
+        parameters: dict[str, Any] | None,
         run_id: str,
-        task_manager: Optional[TaskManager] = None,
-    ) -> Dict[str, Any]:
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
         """Execute workflow with cycle handling.
 
         Args:
@@ -264,8 +264,8 @@ class CyclicWorkflowExecutor:
     def _create_execution_plan(
         self,
         workflow: Workflow,
-        dag_edges: List[Tuple],
-        cycle_groups: Dict[str, List[Tuple]],
+        dag_edges: list[tuple],
+        cycle_groups: dict[str, list[tuple]],
     ) -> "ExecutionPlan":
         """Create execution plan handling cycles.
 
@@ -329,8 +329,8 @@ class CyclicWorkflowExecutor:
         workflow: Workflow,
         plan: "ExecutionPlan",
         state: WorkflowState,
-        task_manager: Optional[TaskManager] = None,
-    ) -> Dict[str, Any]:
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
         """Execute the workflow plan.
 
         Args:
@@ -377,8 +377,8 @@ class CyclicWorkflowExecutor:
         workflow: Workflow,
         cycle_group: "CycleGroup",
         state: WorkflowState,
-        task_manager: Optional[TaskManager] = None,
-    ) -> Dict[str, Any]:
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
         """Execute a cycle group with proper parameter propagation.
 
         Args:
@@ -432,7 +432,7 @@ class CyclicWorkflowExecutor:
                         run_id=state.run_id,
                         node_id=f"cycle_group_{cycle_id}",
                         node_type="CycleGroup",
-                        started_at=datetime.now(timezone.utc),
+                        started_at=datetime.now(UTC),
                         metadata={
                             "cycle_id": cycle_id,
                             "max_iterations": cycle_config.get("max_iterations"),
@@ -463,7 +463,7 @@ class CyclicWorkflowExecutor:
                             run_id=state.run_id,
                             node_id=f"cycle_{cycle_id}_iteration_{loop_count}",
                             node_type="CycleIteration",
-                            started_at=datetime.now(timezone.utc),
+                            started_at=datetime.now(UTC),
                             metadata={
                                 "cycle_id": cycle_id,
                                 "iteration": loop_count,
@@ -552,7 +552,7 @@ class CyclicWorkflowExecutor:
                         task_manager.update_task_status(
                             iteration_task_id,
                             TaskStatus.COMPLETED,
-                            ended_at=datetime.now(timezone.utc),
+                            ended_at=datetime.now(UTC),
                             result=iteration_results,
                             metadata={
                                 "converged": (
@@ -579,7 +579,7 @@ class CyclicWorkflowExecutor:
                     task_manager.update_task_status(
                         cycle_task_id,
                         TaskStatus.COMPLETED,
-                        ended_at=datetime.now(timezone.utc),
+                        ended_at=datetime.now(UTC),
                         result=results,
                         metadata={
                             "total_iterations": loop_count,
@@ -603,11 +603,11 @@ class CyclicWorkflowExecutor:
         workflow: Workflow,
         node_id: str,
         state: WorkflowState,
-        cycle_state: Optional[CycleState] = None,
-        cycle_edges: Optional[List[Tuple]] = None,
-        previous_iteration_results: Optional[Dict[str, Any]] = None,
-        task_manager: Optional[TaskManager] = None,
-        iteration: Optional[int] = None,
+        cycle_state: CycleState | None = None,
+        cycle_edges: list[tuple] | None = None,
+        previous_iteration_results: dict[str, Any] | None = None,
+        task_manager: TaskManager | None = None,
+        iteration: int | None = None,
     ) -> Any:
         """Execute a single node with proper parameter handling for cycles.
 
@@ -757,7 +757,7 @@ class CyclicWorkflowExecutor:
                     run_id=state.run_id,
                     node_id=task_node_id,
                     node_type=node.__class__.__name__,
-                    started_at=datetime.now(timezone.utc),
+                    started_at=datetime.now(UTC),
                     metadata=task_metadata,
                 )
                 if task:
@@ -794,7 +794,7 @@ class CyclicWorkflowExecutor:
                         task.task_id,
                         TaskStatus.COMPLETED,
                         result=result,
-                        ended_at=datetime.now(timezone.utc),
+                        ended_at=datetime.now(UTC),
                         metadata={"execution_time": performance_metrics.duration},
                     )
 
@@ -811,7 +811,7 @@ class CyclicWorkflowExecutor:
                         task.task_id,
                         TaskStatus.FAILED,
                         error=str(e),
-                        ended_at=datetime.now(timezone.utc),
+                        ended_at=datetime.now(UTC),
                     )
                 except Exception as update_error:
                     logger.warning(
@@ -831,16 +831,16 @@ class ExecutionPlan:
 
     def __init__(self):
         """Initialize execution plan."""
-        self.stages: List["ExecutionStage"] = []
-        self.cycle_groups: Dict[str, "CycleGroup"] = {}
+        self.stages: list["ExecutionStage"] = []
+        self.cycle_groups: dict[str, "CycleGroup"] = {}
 
     def add_cycle_group(
         self,
         cycle_id: str,
-        nodes: Set[str],
-        entry_nodes: Set[str],
-        exit_nodes: Set[str],
-        edges: List[Tuple],
+        nodes: set[str],
+        entry_nodes: set[str],
+        exit_nodes: set[str],
+        edges: list[tuple],
     ) -> None:
         """Add a cycle group to the plan.
 
@@ -859,7 +859,7 @@ 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) -> None:
         """Build execution stages.
 
         Args:
@@ -914,7 +914,7 @@ class ExecutionStage:
     def __init__(
         self,
         is_cycle: bool,
-        nodes: Optional[List[str]] = None,
+        nodes: list[str] | None = None,
         cycle_group: Optional["CycleGroup"] = None,
     ):
         """Initialize execution stage.
@@ -935,10 +935,10 @@ class CycleGroup:
     def __init__(
         self,
         cycle_id: str,
-        nodes: Set[str],
-        entry_nodes: Set[str],
-        exit_nodes: Set[str],
-        edges: List[Tuple],
+        nodes: set[str],
+        entry_nodes: set[str],
+        exit_nodes: set[str],
+        edges: list[tuple],
     ):
         """Initialize cycle group.
 
@@ -955,7 +955,7 @@ class CycleGroup:
         self.exit_nodes = exit_nodes
         self.edges = edges
 
-    def get_execution_order(self, full_graph: nx.DiGraph) -> List[str]:
+    def get_execution_order(self, full_graph: nx.DiGraph) -> list[str]:
         """Get execution order for nodes in cycle.
 
         Args: