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

kailash/workflow/graph.py

@@ -4,8 +4,8 @@ import json
 import logging
 import uuid
 import warnings
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple
+from datetime import UTC, datetime
+from typing import Any
 
 import networkx as nx
 import yaml
@@ -38,10 +38,10 @@ class NodeInstance(BaseModel):
 
     node_id: str = Field(..., description="Unique identifier for this instance")
     node_type: str = Field(..., description="Type of node")
-    config: Dict[str, Any] = Field(
+    config: dict[str, Any] = Field(
         default_factory=dict, description="Node configuration"
     )
-    position: Tuple[float, float] = Field(default=(0, 0), description="Visual position")
+    position: tuple[float, float] = Field(default=(0, 0), description="Visual position")
 
 
 class Connection(BaseModel):
@@ -59,23 +59,21 @@ class CyclicConnection(Connection):
     cycle: bool = Field(
         default=False, description="Whether this connection creates a cycle"
     )
-    max_iterations: Optional[int] = Field(
+    max_iterations: int | None = Field(
         default=None, description="Maximum cycle iterations"
     )
-    convergence_check: Optional[str] = Field(
+    convergence_check: str | None = Field(
         default=None, description="Convergence condition expression"
     )
-    cycle_id: Optional[str] = Field(
+    cycle_id: str | None = Field(
         default=None, description="Logical cycle group identifier"
     )
-    timeout: Optional[float] = Field(
-        default=None, description="Cycle timeout in seconds"
-    )
-    memory_limit: Optional[int] = Field(default=None, description="Memory limit in MB")
-    condition: Optional[str] = Field(
+    timeout: float | None = Field(default=None, description="Cycle timeout in seconds")
+    memory_limit: int | None = Field(default=None, description="Memory limit in MB")
+    condition: str | None = Field(
         default=None, description="Conditional cycle routing expression"
     )
-    parent_cycle: Optional[str] = Field(
+    parent_cycle: str | None = Field(
         default=None, description="Parent cycle for nested cycles"
     )
 
@@ -90,7 +88,7 @@ class Workflow:
         description: str = "",
         version: str = "1.0.0",
         author: str = "",
-        metadata: Optional[Dict[str, Any]] = None,
+        metadata: dict[str, Any] | None = None,
     ):
         """Initialize a workflow.
 
@@ -118,7 +116,7 @@ class Workflow:
         if "version" not in self.metadata and version:
             self.metadata["version"] = version
         if "created_at" not in self.metadata:
-            self.metadata["created_at"] = datetime.now(timezone.utc).isoformat()
+            self.metadata["created_at"] = datetime.now(UTC).isoformat()
 
         # Create directed graph for the workflow
         self.graph = nx.DiGraph()
@@ -212,7 +210,7 @@ class Workflow:
         logger.info(f"Added node '{node_id}' of type '{node_type}'")
 
     def _add_node_internal(
-        self, node_id: str, node_type: str, config: Optional[Dict[str, Any]] = None
+        self, node_id: str, node_type: str, config: dict[str, Any] | None = None
     ) -> None:
         """Add a node to the workflow (internal method).
 
@@ -229,15 +227,15 @@ class Workflow:
         self,
         source_node: str,
         target_node: str,
-        mapping: Optional[Dict[str, str]] = None,
+        mapping: dict[str, str] | None = None,
         cycle: bool = False,
-        max_iterations: Optional[int] = None,
-        convergence_check: Optional[str] = None,
-        cycle_id: Optional[str] = None,
-        timeout: Optional[float] = None,
-        memory_limit: Optional[int] = None,
-        condition: Optional[str] = None,
-        parent_cycle: Optional[str] = None,
+        max_iterations: int | None = None,
+        convergence_check: str | None = None,
+        cycle_id: str | None = None,
+        timeout: float | None = None,
+        memory_limit: int | None = None,
+        condition: str | None = None,
+        parent_cycle: str | None = None,
     ) -> None:
         """Connect two nodes in the workflow.
 
@@ -443,7 +441,7 @@ class Workflow:
                 f"Connected '{source_node}' to '{target_node}' with mapping: {mapping}"
             )
 
-    def create_cycle(self, cycle_id: Optional[str] = None):
+    def create_cycle(self, cycle_id: str | None = None):
         """
         Create a new CycleBuilder for intuitive cycle configuration.
 
@@ -541,7 +539,7 @@ class Workflow:
             source_node=from_node, target_node=to_node, mapping={from_output: to_input}
         )
 
-    def get_node(self, node_id: str) -> Optional[Node]:
+    def get_node(self, node_id: str) -> Node | None:
         """Get node instance by ID.
 
         Args:
@@ -561,7 +559,7 @@ class Workflow:
         # Fallback to _node_instances
         return self._node_instances.get(node_id)
 
-    def separate_dag_and_cycle_edges(self) -> Tuple[List[Tuple], List[Tuple]]:
+    def separate_dag_and_cycle_edges(self) -> tuple[list[tuple], list[tuple]]:
         """Separate DAG edges from cycle edges.
 
         Returns:
@@ -578,7 +576,7 @@ class Workflow:
 
         return dag_edges, cycle_edges
 
-    def get_cycle_groups(self) -> Dict[str, List[Tuple]]:
+    def get_cycle_groups(self) -> dict[str, list[tuple]]:
         """Get cycle edges grouped by cycle_id with enhanced multi-node cycle detection.
 
         For multi-node cycles like A → B → C → A where only C → A is marked as cycle,
@@ -678,7 +676,7 @@ class Workflow:
         _, cycle_edges = self.separate_dag_and_cycle_edges()
         return len(cycle_edges) > 0
 
-    def get_execution_order(self) -> List[str]:
+    def get_execution_order(self) -> list[str]:
         """Get topological execution order for nodes, handling cycles gracefully.
 
         Returns:
@@ -711,7 +709,7 @@ class Workflow:
                 # This shouldn't happen, but handle gracefully
                 raise WorkflowValidationError("Unable to determine execution order")
 
-    def validate(self, runtime_parameters: Optional[Dict[str, Any]] = None) -> None:
+    def validate(self, runtime_parameters: dict[str, Any] | None = None) -> None:
         """Validate the workflow structure.
 
         Args:
@@ -843,8 +841,8 @@ class Workflow:
                 )
 
     def run(
-        self, task_manager: Optional[TaskManager] = None, **overrides
-    ) -> Tuple[Dict[str, Any], Optional[str]]:
+        self, task_manager: TaskManager | None = None, **overrides
+    ) -> tuple[dict[str, Any], str | None]:
         """Execute the workflow.
 
         Args:
@@ -863,9 +861,9 @@ class Workflow:
 
     def execute(
         self,
-        inputs: Optional[Dict[str, Any]] = None,
-        task_manager: Optional[TaskManager] = None,
-    ) -> Dict[str, Any]:
+        inputs: dict[str, Any] | None = None,
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
         """Execute the workflow.
 
         Args:
@@ -963,7 +961,9 @@ class Workflow:
                         )
 
                         # Process each mapping pair
-                        for i, (src, dst) in enumerate(zip(from_outputs, to_inputs)):
+                        for i, (src, dst) in enumerate(
+                            zip(from_outputs, to_inputs, strict=False)
+                        ):
                             if src in source_results:
                                 node_inputs[dst] = source_results[src]
 
@@ -1045,7 +1045,7 @@ class Workflow:
                 f"Failed to export workflow to '{output_path}': {e}"
             ) from e
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert workflow to dictionary.
 
         Returns:
@@ -1107,7 +1107,7 @@ class Workflow:
             raise ValueError(f"Unsupported format: {format}")
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Workflow":
+    def from_dict(cls, data: dict[str, Any]) -> "Workflow":
         """Create workflow from dictionary.
 
         Args:
@@ -1228,9 +1228,9 @@ class Workflow:
         self,
         state_model: BaseModel,
         wrap_state: bool = True,
-        task_manager: Optional[TaskManager] = None,
+        task_manager: TaskManager | None = None,
         **overrides,
-    ) -> Tuple[BaseModel, Dict[str, Any]]:
+    ) -> tuple[BaseModel, dict[str, Any]]:
         """Execute the workflow with state management.
 
         This method provides a simplified interface for executing workflows

kailash/workflow/mermaid_visualizer.py

@@ -5,8 +5,6 @@ offering a text-based format that can be embedded in markdown files and
 rendered in various documentation platforms.
 """
 
-from typing import Dict, Optional, Tuple
-
 from kailash.workflow.graph import Workflow
 
 
@@ -27,7 +25,7 @@ class MermaidVisualizer:
         self,
         workflow: Workflow,
         direction: str = "TB",
-        node_styles: Optional[Dict[str, str]] = None,
+        node_styles: dict[str, str] | None = None,
     ):
         """Initialize the Mermaid visualizer.
 
@@ -40,7 +38,7 @@ class MermaidVisualizer:
         self.direction = direction
         self.node_styles = node_styles or self._default_node_styles()
 
-    def _default_node_styles(self) -> Dict[str, str]:
+    def _default_node_styles(self) -> dict[str, str]:
         """Get default node styles for different node types.
 
         Returns:
@@ -79,7 +77,7 @@ class MermaidVisualizer:
         # Use line break without parentheses to avoid Mermaid parsing issues
         return f"{clean_type}<br/>{node_id}"
 
-    def _get_pattern_edge_label(self, source: str, target: str, data: Dict) -> str:
+    def _get_pattern_edge_label(self, source: str, target: str, data: dict) -> str:
         """Get a pattern-oriented edge label.
 
         Args:
@@ -262,7 +260,7 @@ class MermaidVisualizer:
             return node_type[:-4]
         return node_type
 
-    def _get_node_shape(self, node_type: str) -> Tuple[str, str]:
+    def _get_node_shape(self, node_type: str) -> tuple[str, str]:
         """Get the shape brackets for a node type.
 
         Args:
@@ -460,7 +458,7 @@ class MermaidVisualizer:
 
         return "\n".join(lines)
 
-    def _get_edge_label(self, source: str, target: str, data: Dict) -> str:
+    def _get_edge_label(self, source: str, target: str, data: dict) -> str:
         """Get label for an edge.
 
         Args:
@@ -491,7 +489,7 @@ class MermaidVisualizer:
 
         return ""
 
-    def generate_markdown(self, title: Optional[str] = None) -> str:
+    def generate_markdown(self, title: str | None = None) -> str:
         """Generate a complete markdown section with the Mermaid diagram.
 
         Args:
@@ -559,7 +557,7 @@ class MermaidVisualizer:
 
         return "\n".join(lines)
 
-    def save_markdown(self, filepath: str, title: Optional[str] = None) -> None:
+    def save_markdown(self, filepath: str, title: str | None = None) -> None:
         """Save the Mermaid diagram as a markdown file.
 
         Args:
@@ -596,7 +594,7 @@ def add_mermaid_to_workflow():
         visualizer = MermaidVisualizer(self, direction=direction)
         return visualizer.generate()
 
-    def to_mermaid_markdown(self, title: Optional[str] = None) -> str:
+    def to_mermaid_markdown(self, title: str | None = None) -> str:
         """Generate markdown with embedded Mermaid diagram.
 
         Args:
@@ -608,7 +606,7 @@ def add_mermaid_to_workflow():
         visualizer = MermaidVisualizer(self)
         return visualizer.generate_markdown(title)
 
-    def save_mermaid_markdown(self, filepath: str, title: Optional[str] = None) -> None:
+    def save_mermaid_markdown(self, filepath: str, title: str | None = None) -> None:
         """Save workflow as markdown with Mermaid diagram.
 
         Args:

kailash/workflow/migration.py

@@ -103,7 +103,7 @@ See Also:
 import re
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from . import Workflow
 from .templates import CycleTemplates
@@ -113,11 +113,11 @@ from .templates import CycleTemplates
 class CyclificationOpportunity:
     """Represents an opportunity to convert a DAG pattern to a cycle."""
 
-    nodes: List[str]
+    nodes: list[str]
     pattern_type: str
     confidence: float
     description: str
-    suggested_convergence: Optional[str] = None
+    suggested_convergence: str | None = None
     estimated_benefit: str = "unknown"
     implementation_complexity: str = "medium"
 
@@ -127,10 +127,10 @@ class CyclificationSuggestion:
     """Detailed suggestion for converting nodes to a cycle."""
 
     opportunity: CyclificationOpportunity
-    implementation_steps: List[str]
+    implementation_steps: list[str]
     code_example: str
     expected_outcome: str
-    risks: List[str]
+    risks: list[str]
 
 
 class DAGToCycleConverter:
@@ -150,9 +150,9 @@ class DAGToCycleConverter:
         """
         self.workflow = workflow
         self.graph = workflow.graph
-        self.opportunities: List[CyclificationOpportunity] = []
+        self.opportunities: list[CyclificationOpportunity] = []
 
-    def analyze_cyclification_opportunities(self) -> List[CyclificationOpportunity]:
+    def analyze_cyclification_opportunities(self) -> list[CyclificationOpportunity]:
         """
         Analyze workflow for patterns that could benefit from cyclification.
 
@@ -322,7 +322,7 @@ class DAGToCycleConverter:
                 )
                 self.opportunities.append(opportunity)
 
-    def _find_related_nodes(self, node_id: str) -> List[str]:
+    def _find_related_nodes(self, node_id: str) -> list[str]:
         """Find nodes that are closely related to the given node."""
         related = []
 
@@ -343,7 +343,7 @@ class DAGToCycleConverter:
         # Check if there's an edge between the nodes in either direction
         return graph.has_edge(node1, node2) or graph.has_edge(node2, node1)
 
-    def generate_detailed_suggestions(self) -> List[CyclificationSuggestion]:
+    def generate_detailed_suggestions(self) -> list[CyclificationSuggestion]:
         """
         Generate detailed suggestions with implementation guidance.
 
@@ -602,9 +602,9 @@ print(f"Created convergence cycle: {{cycle_id}}")
 
     def convert_to_cycle(
         self,
-        nodes: List[str],
+        nodes: list[str],
         convergence_strategy: str = "error_reduction",
-        cycle_type: Optional[str] = None,
+        cycle_type: str | None = None,
         **kwargs,
     ) -> str:
         """
@@ -643,7 +643,7 @@ print(f"Created convergence cycle: {{cycle_id}}")
         else:
             raise ValueError(f"Unknown cycle type: {cycle_type}")
 
-    def _detect_cycle_type(self, nodes: List[str], strategy: str) -> str:
+    def _detect_cycle_type(self, nodes: list[str], strategy: str) -> str:
         """Detect the most appropriate cycle type for given nodes and strategy."""
         if strategy == "error_reduction" or strategy == "quality_improvement":
             return "optimization"
@@ -659,7 +659,7 @@ print(f"Created convergence cycle: {{cycle_id}}")
             # Default to optimization for unknown strategies
             return "optimization"
 
-    def _convert_to_optimization_cycle(self, nodes: List[str], **kwargs) -> str:
+    def _convert_to_optimization_cycle(self, nodes: list[str], **kwargs) -> str:
         """Convert nodes to optimization cycle."""
         if len(nodes) < 2:
             raise ValueError("Optimization cycle requires at least 2 nodes")
@@ -668,14 +668,14 @@ print(f"Created convergence cycle: {{cycle_id}}")
             self.workflow, processor_node=nodes[0], evaluator_node=nodes[1], **kwargs
         )
 
-    def _convert_to_retry_cycle(self, nodes: List[str], **kwargs) -> str:
+    def _convert_to_retry_cycle(self, nodes: list[str], **kwargs) -> str:
         """Convert nodes to retry cycle."""
         if len(nodes) < 1:
             raise ValueError("Retry cycle requires at least 1 node")
 
         return CycleTemplates.retry_cycle(self.workflow, target_node=nodes[0], **kwargs)
 
-    def _convert_to_data_quality_cycle(self, nodes: List[str], **kwargs) -> str:
+    def _convert_to_data_quality_cycle(self, nodes: list[str], **kwargs) -> str:
         """Convert nodes to data quality cycle."""
         if len(nodes) < 2:
             raise ValueError("Data quality cycle requires at least 2 nodes")
@@ -684,7 +684,7 @@ print(f"Created convergence cycle: {{cycle_id}}")
             self.workflow, cleaner_node=nodes[0], validator_node=nodes[1], **kwargs
         )
 
-    def _convert_to_batch_processing_cycle(self, nodes: List[str], **kwargs) -> str:
+    def _convert_to_batch_processing_cycle(self, nodes: list[str], **kwargs) -> str:
         """Convert nodes to batch processing cycle."""
         if len(nodes) < 1:
             raise ValueError("Batch processing cycle requires at least 1 node")
@@ -693,7 +693,7 @@ print(f"Created convergence cycle: {{cycle_id}}")
             self.workflow, processor_node=nodes[0], **kwargs
         )
 
-    def _convert_to_convergence_cycle(self, nodes: List[str], **kwargs) -> str:
+    def _convert_to_convergence_cycle(self, nodes: list[str], **kwargs) -> str:
         """Convert nodes to convergence cycle."""
         if len(nodes) < 1:
             raise ValueError("Convergence cycle requires at least 1 node")
@@ -702,7 +702,7 @@ print(f"Created convergence cycle: {{cycle_id}}")
             self.workflow, processor_node=nodes[0], **kwargs
         )
 
-    def generate_migration_report(self) -> Dict[str, Any]:
+    def generate_migration_report(self) -> dict[str, Any]:
         """
         Generate comprehensive migration report with analysis and recommendations.
 
@@ -745,8 +745,8 @@ print(f"Created convergence cycle: {{cycle_id}}")
         }
 
     def _generate_migration_recommendations(
-        self, opportunities: List[CyclificationOpportunity]
-    ) -> List[str]:
+        self, opportunities: list[CyclificationOpportunity]
+    ) -> list[str]:
         """Generate high-level recommendations for migration."""
         recommendations = []
 
@@ -779,8 +779,8 @@ print(f"Created convergence cycle: {{cycle_id}}")
         return recommendations
 
     def _suggest_implementation_order(
-        self, opportunities: List[CyclificationOpportunity]
-    ) -> List[Dict[str, Any]]:
+        self, opportunities: list[CyclificationOpportunity]
+    ) -> list[dict[str, Any]]:
         """Suggest order for implementing cyclification opportunities."""
         # Sort by: confidence desc, complexity asc (low=1, medium=2, high=3)
         complexity_score = {"low": 1, "medium": 2, "high": 3}

kailash/workflow/mock_registry.py

@@ -1,6 +1,6 @@
 """Mock node registry for tests."""
 
-from typing import Any, Dict, Type
+from typing import Any
 
 from kailash.nodes.base import Node, NodeRegistry
 from kailash.sdk_exceptions import NodeConfigurationError
@@ -15,15 +15,15 @@ class MockNode(Node):
         self.name = name or node_id
         self.config = kwargs.copy()
 
-    def process(self, data: Dict[str, Any]) -> Dict[str, Any]:
+    def process(self, data: dict[str, Any]) -> dict[str, Any]:
         """Process data."""
         return {"value": data.get("value", 0) * 2}
 
-    def execute(self, **kwargs) -> Dict[str, Any]:
+    def execute(self, **kwargs) -> dict[str, Any]:
         """Execute node with keyword arguments."""
         return self.process(kwargs)
 
-    def get_parameters(self) -> Dict[str, Any]:
+    def get_parameters(self) -> dict[str, Any]:
         """Get node parameters."""
         return {}
 
@@ -50,10 +50,10 @@ for node_type in NODE_TYPES:
 class MockRegistry:
     """Mock node registry for testing."""
 
-    _registry: Dict[str, Type[Node]] = {node_type: MockNode for node_type in NODE_TYPES}
+    _registry: dict[str, type[Node]] = {node_type: MockNode for node_type in NODE_TYPES}
 
     @classmethod
-    def get(cls, node_type: str) -> Type[Node]:
+    def get(cls, node_type: str) -> type[Node]:
         """Get node class by type name."""
         if node_type not in cls._registry:
             raise NodeConfigurationError(

kailash/workflow/runner.py

@@ -5,7 +5,7 @@ allowing for complex multi-stage processing pipelines.
 """
 
 import logging
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -23,8 +23,8 @@ class WorkflowConnection:
         self,
         source_workflow_id: str,
         target_workflow_id: str,
-        condition: Optional[Dict[str, Any]] = None,
-        state_mapping: Optional[Dict[str, str]] = None,
+        condition: dict[str, Any] | None = None,
+        state_mapping: dict[str, str] | None = None,
     ):
         """Initialize a workflow connection.
 
@@ -88,7 +88,7 @@ class WorkflowConnection:
             )
             return True
 
-    def map_state(self, state: BaseModel) -> Dict[str, Any]:
+    def map_state(self, state: BaseModel) -> dict[str, Any]:
         """Map state fields according to the mapping configuration.
 
         Args:
@@ -142,8 +142,8 @@ class WorkflowRunner:
         self,
         source_workflow_id: str,
         target_workflow_id: str,
-        condition: Optional[Dict[str, Any]] = None,
-        state_mapping: Optional[Dict[str, str]] = None,
+        condition: dict[str, Any] | None = None,
+        state_mapping: dict[str, str] | None = None,
     ) -> None:
         """Connect two workflows.
 
@@ -182,7 +182,7 @@ class WorkflowRunner:
 
     def get_next_workflows(
         self, current_workflow_id: str, state: BaseModel
-    ) -> List[Tuple[str, Dict[str, Any]]]:
+    ) -> list[tuple[str, dict[str, Any]]]:
         """Get the next workflows to execute based on current state.
 
         Args:
@@ -206,9 +206,9 @@ class WorkflowRunner:
         self,
         entry_workflow_id: str,
         initial_state: BaseModel,
-        task_manager: Optional[TaskManager] = None,
+        task_manager: TaskManager | None = None,
         max_steps: int = 10,  # Prevent infinite loops
-    ) -> Tuple[BaseModel, Dict[str, Dict[str, Any]]]:
+    ) -> tuple[BaseModel, dict[str, dict[str, Any]]]:
         """Execute a sequence of connected workflows.
 
         Args:

kailash/workflow/safety.py

@@ -4,7 +4,6 @@ import logging
 import threading
 import time
 from contextlib import contextmanager
-from typing import Dict, Optional, Set
 
 import psutil
 
@@ -18,13 +17,13 @@ class CycleSafetyManager:
 
     def __init__(self):
         """Initialize cycle safety manager."""
-        self.active_cycles: Dict[str, "CycleMonitor"] = {}
+        self.active_cycles: dict[str, "CycleMonitor"] = {}
         self.global_memory_limit = None  # MB
         self.global_timeout = None  # seconds
         self._lock = threading.Lock()
 
     def set_global_limits(
-        self, memory_limit: Optional[int] = None, timeout: Optional[float] = None
+        self, memory_limit: int | None = None, timeout: float | None = None
     ) -> None:
         """Set global resource limits.
 
@@ -38,9 +37,9 @@ class CycleSafetyManager:
     def start_monitoring(
         self,
         cycle_id: str,
-        max_iterations: Optional[int] = None,
-        timeout: Optional[float] = None,
-        memory_limit: Optional[int] = None,
+        max_iterations: int | None = None,
+        timeout: float | None = None,
+        memory_limit: int | None = None,
     ) -> "CycleMonitor":
         """Start monitoring a cycle.
 
@@ -88,7 +87,7 @@ class CycleSafetyManager:
                 monitor.stop()
                 del self.active_cycles[cycle_id]
 
-    def check_all_cycles(self) -> Dict[str, bool]:
+    def check_all_cycles(self) -> dict[str, bool]:
         """Check all active cycles for violations.
 
         Returns:
@@ -102,7 +101,7 @@ class CycleSafetyManager:
 
         return violations
 
-    def get_cycle_status(self, cycle_id: str) -> Optional[Dict[str, any]]:
+    def get_cycle_status(self, cycle_id: str) -> dict[str, any] | None:
         """Get status of a specific cycle.
 
         Args:
@@ -116,7 +115,7 @@ class CycleSafetyManager:
                 return self.active_cycles[cycle_id].get_status()
         return None
 
-    def detect_deadlocks(self) -> Set[str]:
+    def detect_deadlocks(self) -> set[str]:
         """Detect potential deadlocks in active cycles.
 
         Returns:
@@ -138,9 +137,9 @@ class CycleMonitor:
     def __init__(
         self,
         cycle_id: str,
-        max_iterations: Optional[int] = None,
-        timeout: Optional[float] = None,
-        memory_limit: Optional[int] = None,
+        max_iterations: int | None = None,
+        timeout: float | None = None,
+        memory_limit: int | None = None,
     ):
         """Initialize cycle monitor.
 
@@ -256,7 +255,7 @@ class CycleMonitor:
         time_since_progress = time.time() - self.last_progress_time
         return time_since_progress > stall_threshold
 
-    def get_status(self) -> Dict[str, any]:
+    def get_status(self) -> dict[str, any]:
         """Get current monitor status.
 
         Returns: