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

kailash/workflow/builder.py

@@ -2,7 +2,7 @@
 
 import logging
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from kailash.sdk_exceptions import ConnectionError, WorkflowValidationError
 from kailash.workflow.graph import Workflow
@@ -15,15 +15,15 @@ class WorkflowBuilder:
 
     def __init__(self):
         """Initialize an empty workflow builder."""
-        self.nodes: Dict[str, Dict[str, Any]] = {}
-        self.connections: List[Dict[str, str]] = []
-        self._metadata: Dict[str, Any] = {}
+        self.nodes: dict[str, dict[str, Any]] = {}
+        self.connections: list[dict[str, str]] = []
+        self._metadata: dict[str, Any] = {}
 
     def add_node(
         self,
         node_type: str,
-        node_id: Optional[str] = None,
-        config: Optional[Dict[str, Any]] = None,
+        node_id: str | None = None,
+        config: dict[str, Any] | None = None,
     ) -> str:
         """
         Add a node to the workflow.
@@ -106,7 +106,7 @@ class WorkflowBuilder:
         self._metadata.update(kwargs)
         return self
 
-    def build(self, workflow_id: Optional[str] = None, **kwargs) -> Workflow:
+    def build(self, workflow_id: str | None = None, **kwargs) -> Workflow:
         """
         Build and return a Workflow instance.
 
@@ -193,7 +193,7 @@ class WorkflowBuilder:
         return self
 
     @classmethod
-    def from_dict(cls, config: Dict[str, Any]) -> "WorkflowBuilder":
+    def from_dict(cls, config: dict[str, Any]) -> "WorkflowBuilder":
         """
         Create builder from dictionary configuration.
 

kailash/workflow/convergence.py

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

kailash/workflow/cycle_analyzer.py

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

kailash/workflow/cycle_builder.py

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

kailash/workflow/cycle_config.py

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