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

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:

kailash/workflow/state.py

@@ -6,7 +6,7 @@ making it easier to handle state transitions in a predictable manner.
 
 import logging
 from copy import deepcopy
-from typing import Any, Generic, List, Tuple, TypeVar
+from typing import Any, Generic, TypeVar
 
 from pydantic import BaseModel
 
@@ -24,7 +24,7 @@ class StateManager:
     """
 
     @staticmethod
-    def update_in(state_obj: BaseModel, path: List[str], value: Any) -> BaseModel:
+    def update_in(state_obj: BaseModel, path: list[str], value: Any) -> BaseModel:
         """Update a nested property in the state and return a new state object.
 
         Args:
@@ -61,10 +61,7 @@ class StateManager:
             if isinstance(next_obj, BaseModel):
                 next_obj = next_obj.model_copy(deep=True)
                 setattr(current, key, next_obj)
-            elif isinstance(next_obj, dict):
-                next_obj = deepcopy(next_obj)
-                setattr(current, key, next_obj)
-            elif isinstance(next_obj, list):
+            elif isinstance(next_obj, dict) or isinstance(next_obj, list):
                 next_obj = deepcopy(next_obj)
                 setattr(current, key, next_obj)
 
@@ -80,7 +77,7 @@ class StateManager:
 
     @staticmethod
     def batch_update(
-        state_obj: BaseModel, updates: List[Tuple[List[str], Any]]
+        state_obj: BaseModel, updates: list[tuple[list[str], Any]]
     ) -> BaseModel:
         """Apply multiple updates to the state atomically.
 
@@ -108,7 +105,7 @@ class StateManager:
         return new_state
 
     @staticmethod
-    def get_in(state_obj: BaseModel, path: List[str]) -> Any:
+    def get_in(state_obj: BaseModel, path: list[str]) -> Any:
         """Get the value at a nested path.
 
         Args:
@@ -175,7 +172,7 @@ class WorkflowStateWrapper(Generic[StateT]):
         """
         self._state = state
 
-    def update_in(self, path: List[str], value: Any) -> "WorkflowStateWrapper[StateT]":
+    def update_in(self, path: list[str], value: Any) -> "WorkflowStateWrapper[StateT]":
         """Update state at path and return new wrapper.
 
         Args:
@@ -189,7 +186,7 @@ class WorkflowStateWrapper(Generic[StateT]):
         return WorkflowStateWrapper(new_state)
 
     def batch_update(
-        self, updates: List[Tuple[List[str], Any]]
+        self, updates: list[tuple[list[str], Any]]
     ) -> "WorkflowStateWrapper[StateT]":
         """Apply multiple updates to the state atomically.
 
@@ -202,7 +199,7 @@ class WorkflowStateWrapper(Generic[StateT]):
         new_state = StateManager.batch_update(self._state, updates)
         return WorkflowStateWrapper(new_state)
 
-    def get_in(self, path: List[str]) -> Any:
+    def get_in(self, path: list[str]) -> Any:
         """Get the value at a nested path.
 
         Args:

kailash/workflow/templates.py

@@ -113,7 +113,7 @@ See Also:
 import math
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from ..nodes.code import PythonCodeNode
 from . import Workflow
@@ -125,11 +125,11 @@ class CycleTemplate:
 
     name: str
     description: str
-    nodes: List[str]
-    convergence_condition: Optional[str] = None
+    nodes: list[str]
+    convergence_condition: str | None = None
     max_iterations: int = 100
-    timeout: Optional[float] = None
-    parameters: Optional[Dict[str, Any]] = None
+    timeout: float | None = None
+    parameters: dict[str, Any] | None = None
 
 
 class CycleTemplates:
@@ -142,7 +142,7 @@ class CycleTemplates:
         evaluator_node: str,
         convergence: str = "quality > 0.9",
         max_iterations: int = 50,
-        cycle_id: Optional[str] = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add an optimization cycle pattern to workflow.
@@ -195,7 +195,7 @@ class CycleTemplates:
         max_retries: int = 3,
         backoff_strategy: str = "exponential",
         success_condition: str = "success == True",
-        cycle_id: Optional[str] = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add a retry cycle pattern to workflow.
@@ -300,7 +300,7 @@ result = {{
         validator_node: str,
         quality_threshold: float = 0.95,
         max_iterations: int = 10,
-        cycle_id: Optional[str] = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add a data quality improvement cycle to workflow.
@@ -353,7 +353,7 @@ result = {{
         target_accuracy: float = 0.95,
         max_epochs: int = 100,
         early_stopping_patience: int = 10,
-        cycle_id: Optional[str] = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add a machine learning training cycle to workflow.
@@ -462,7 +462,7 @@ result = {{
         processor_node: str,
         tolerance: float = 0.001,
         max_iterations: int = 1000,
-        cycle_id: Optional[str] = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add a numerical convergence cycle to workflow.
@@ -560,8 +560,8 @@ previous_value = current_value
         workflow: Workflow,
         processor_node: str,
         batch_size: int = 100,
-        total_items: Optional[int] = None,
-        cycle_id: Optional[str] = None,
+        total_items: int | None = None,
+        cycle_id: str | None = None,
     ) -> str:
         """
         Add a batch processing cycle to workflow.
@@ -671,7 +671,7 @@ def add_optimization_cycle(
     evaluator_node: str,
     convergence: str = "quality > 0.9",
     max_iterations: int = 50,
-    cycle_id: Optional[str] = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add an optimization cycle pattern to this workflow."""
     return CycleTemplates.optimization_cycle(
@@ -685,7 +685,7 @@ def add_retry_cycle(
     max_retries: int = 3,
     backoff_strategy: str = "exponential",
     success_condition: str = "success == True",
-    cycle_id: Optional[str] = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add a retry cycle pattern to this workflow."""
     return CycleTemplates.retry_cycle(
@@ -699,7 +699,7 @@ def add_data_quality_cycle(
     validator_node: str,
     quality_threshold: float = 0.95,
     max_iterations: int = 10,
-    cycle_id: Optional[str] = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add a data quality improvement cycle to this workflow."""
     return CycleTemplates.data_quality_cycle(
@@ -714,7 +714,7 @@ def add_learning_cycle(
     target_accuracy: float = 0.95,
     max_epochs: int = 100,
     early_stopping_patience: int = 10,
-    cycle_id: Optional[str] = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add a machine learning training cycle to this workflow."""
     return CycleTemplates.learning_cycle(
@@ -733,7 +733,7 @@ def add_convergence_cycle(
     processor_node: str,
     tolerance: float = 0.001,
     max_iterations: int = 1000,
-    cycle_id: Optional[str] = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add a numerical convergence cycle to this workflow."""
     return CycleTemplates.convergence_cycle(
@@ -745,8 +745,8 @@ def add_batch_processing_cycle(
     self,
     processor_node: str,
     batch_size: int = 100,
-    total_items: Optional[int] = None,
-    cycle_id: Optional[str] = None,
+    total_items: int | None = None,
+    cycle_id: str | None = None,
 ) -> str:
     """Add a batch processing cycle to this workflow."""
     return CycleTemplates.batch_processing_cycle(

kailash/workflow/validation.py

@@ -116,7 +116,7 @@ See Also:
 import re
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from . import Workflow
 
@@ -137,10 +137,10 @@ class ValidationIssue:
     category: str
     code: str
     message: str
-    node_id: Optional[str] = None
-    cycle_id: Optional[str] = None
-    suggestion: Optional[str] = None
-    documentation_link: Optional[str] = None
+    node_id: str | None = None
+    cycle_id: str | None = None
+    suggestion: str | None = None
+    documentation_link: str | None = None
 
 
 class CycleLinter:
@@ -160,9 +160,9 @@ class CycleLinter:
         """
         self.workflow = workflow
         self.graph = workflow.graph
-        self.issues: List[ValidationIssue] = []
+        self.issues: list[ValidationIssue] = []
 
-    def check_all(self) -> List[ValidationIssue]:
+    def check_all(self) -> list[ValidationIssue]:
         """
         Run all validation checks on the workflow.
 
@@ -536,7 +536,7 @@ class CycleLinter:
                             )
                         )
 
-    def _get_cycle_id(self, cycle_nodes: List[str]) -> str:
+    def _get_cycle_id(self, cycle_nodes: list[str]) -> str:
         """Generate a cycle identifier from cycle nodes."""
         return f"cycle_{'-'.join(sorted(cycle_nodes))}"
 
@@ -658,23 +658,23 @@ class CycleLinter:
         node_id_lower = node_id.lower()
         return any(keyword in node_id_lower for keyword in file_keywords)
 
-    def get_issues_by_severity(self, severity: IssueSeverity) -> List[ValidationIssue]:
+    def get_issues_by_severity(self, severity: IssueSeverity) -> list[ValidationIssue]:
         """Get all issues of a specific severity level."""
         return [issue for issue in self.issues if issue.severity == severity]
 
-    def get_issues_by_category(self, category: str) -> List[ValidationIssue]:
+    def get_issues_by_category(self, category: str) -> list[ValidationIssue]:
         """Get all issues of a specific category."""
         return [issue for issue in self.issues if issue.category == category]
 
-    def get_issues_for_cycle(self, cycle_id: str) -> List[ValidationIssue]:
+    def get_issues_for_cycle(self, cycle_id: str) -> list[ValidationIssue]:
         """Get all issues for a specific cycle."""
         return [issue for issue in self.issues if issue.cycle_id == cycle_id]
 
-    def get_issues_for_node(self, node_id: str) -> List[ValidationIssue]:
+    def get_issues_for_node(self, node_id: str) -> list[ValidationIssue]:
         """Get all issues for a specific node."""
         return [issue for issue in self.issues if issue.node_id == node_id]
 
-    def generate_report(self) -> Dict[str, Any]:
+    def generate_report(self) -> dict[str, Any]:
         """
         Generate comprehensive validation report.
 
@@ -724,7 +724,7 @@ class CycleLinter:
             "recommendations": self._generate_recommendations(),
         }
 
-    def _generate_recommendations(self) -> List[str]:
+    def _generate_recommendations(self) -> list[str]:
         """Generate high-level recommendations based on found issues."""
         recommendations = []