kailash 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

kailash/workflow/cycle_exceptions.py

@@ -57,7 +57,7 @@ class CycleException(WorkflowException):
         error_code: str = "CYCLE_ERROR",
         context: Optional[Dict[str, Any]] = None,
         suggestions: Optional[List[str]] = None,
-        documentation_url: Optional[str] = None
+        documentation_url: Optional[str] = None,
     ):
         """
         Initialize cycle exception with enhanced error information.
@@ -77,7 +77,7 @@ class CycleException(WorkflowException):
         self.context = context or {}
         self.suggestions = suggestions or []
         self.documentation_url = documentation_url
-        
+
         # Log error for debugging
         logger.debug(f"CycleException raised: {error_code} - {message}")
 
@@ -99,22 +99,22 @@ class CycleException(WorkflowException):
             Documentation: https://docs.kailash.ai/cycles/configuration'
         """
         message_parts = [f"Error: {self.args[0]}"]
-        
+
         if self.error_code != "CYCLE_ERROR":
             message_parts.append(f"Code: {self.error_code}")
-        
+
         if self.context:
             context_str = ", ".join(f"{k}={v}" for k, v in self.context.items())
             message_parts.append(f"Context: {context_str}")
-        
+
         if self.suggestions:
             message_parts.append("Suggestions:")
             for suggestion in self.suggestions:
                 message_parts.append(f"• {suggestion}")
-        
+
         if self.documentation_url:
             message_parts.append(f"Documentation: {self.documentation_url}")
-        
+
         return "\n".join(message_parts)
 
     def __str__(self) -> str:
@@ -150,7 +150,7 @@ class CycleConfigurationError(CycleException):
         message: str,
         cycle_id: Optional[str] = None,
         invalid_params: Optional[Dict[str, Any]] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize cycle configuration error.
@@ -164,30 +164,30 @@ class CycleConfigurationError(CycleException):
         Side Effects:
             Automatically generates context and suggestions based on parameters
         """
-        context = kwargs.get('context', {})
-        suggestions = kwargs.get('suggestions', [])
-        
+        context = kwargs.get("context", {})
+        suggestions = kwargs.get("suggestions", [])
+
         # Add cycle-specific context
         if cycle_id:
-            context['cycle_id'] = cycle_id
+            context["cycle_id"] = cycle_id
         if invalid_params:
             context.update(invalid_params)
-        
+
         # Add common suggestions if none provided
         if not suggestions:
             suggestions = [
                 "Ensure at least one termination condition (max_iterations, convergence_check, or timeout)",
                 "Use positive values for numeric parameters",
                 "Avoid unsafe operations in convergence expressions",
-                "Check the CycleConfig documentation for valid parameter ranges"
+                "Check the CycleConfig documentation for valid parameter ranges",
             ]
-        
+
         super().__init__(
             message,
-            error_code=kwargs.get('error_code', 'CYCLE_CONFIG_001'),
+            error_code=kwargs.get("error_code", "CYCLE_CONFIG_001"),
             context=context,
             suggestions=suggestions,
-            documentation_url="https://docs.kailash.ai/cycles/configuration"
+            documentation_url="https://docs.kailash.ai/cycles/configuration",
         )
 
 
@@ -220,7 +220,7 @@ class CycleConnectionError(CycleException):
         target_node: Optional[str] = None,
         available_nodes: Optional[List[str]] = None,
         mapping_errors: Optional[Dict[str, str]] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize cycle connection error.
@@ -233,36 +233,40 @@ class CycleConnectionError(CycleException):
             mapping_errors (Dict[str, str], optional): Parameter mapping errors
             **kwargs: Additional arguments for base exception
         """
-        context = kwargs.get('context', {})
-        suggestions = kwargs.get('suggestions', [])
-        
+        context = kwargs.get("context", {})
+        suggestions = kwargs.get("suggestions", [])
+
         # Add connection-specific context
         if source_node:
-            context['source_node'] = source_node
+            context["source_node"] = source_node
         if target_node:
-            context['target_node'] = target_node
+            context["target_node"] = target_node
         if available_nodes:
-            context['available_nodes'] = available_nodes
+            context["available_nodes"] = available_nodes
         if mapping_errors:
-            context['mapping_errors'] = mapping_errors
-        
+            context["mapping_errors"] = mapping_errors
+
         # Generate specific suggestions
         if not suggestions:
             suggestions = []
             if available_nodes:
                 suggestions.append(f"Available nodes: {', '.join(available_nodes)}")
             if source_node and available_nodes and source_node not in available_nodes:
-                suggestions.append(f"Add node '{source_node}' to workflow before connecting")
+                suggestions.append(
+                    f"Add node '{source_node}' to workflow before connecting"
+                )
             if mapping_errors:
-                suggestions.append("Check parameter mappings for typos and type compatibility")
+                suggestions.append(
+                    "Check parameter mappings for typos and type compatibility"
+                )
             suggestions.append("Verify node IDs match exactly (case-sensitive)")
-        
+
         super().__init__(
             message,
-            error_code=kwargs.get('error_code', 'CYCLE_CONN_001'),
+            error_code=kwargs.get("error_code", "CYCLE_CONN_001"),
             context=context,
             suggestions=suggestions,
-            documentation_url="https://docs.kailash.ai/cycles/connections"
+            documentation_url="https://docs.kailash.ai/cycles/connections",
         )
 
 
@@ -293,7 +297,7 @@ class CycleValidationError(CycleException):
         cycle_group: Optional[str] = None,
         validation_failures: Optional[List[str]] = None,
         conflicting_values: Optional[List[Any]] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize cycle validation error.
@@ -305,34 +309,34 @@ class CycleValidationError(CycleException):
             conflicting_values (List[Any], optional): Conflicting parameter values
             **kwargs: Additional arguments for base exception
         """
-        context = kwargs.get('context', {})
-        suggestions = kwargs.get('suggestions', [])
-        
+        context = kwargs.get("context", {})
+        suggestions = kwargs.get("suggestions", [])
+
         # Add validation-specific context
         if cycle_group:
-            context['cycle_group'] = cycle_group
+            context["cycle_group"] = cycle_group
         if validation_failures:
-            context['validation_failures'] = validation_failures
+            context["validation_failures"] = validation_failures
         if conflicting_values:
-            context['conflicting_values'] = conflicting_values
-        
+            context["conflicting_values"] = conflicting_values
+
         # Generate validation-specific suggestions
         if not suggestions:
             suggestions = [
                 "Review cycle configuration for consistency",
                 "Ensure all cycle edges use the same parameters",
                 "Check for proper cycle marking (cycle=True)",
-                "Validate nested cycle relationships"
+                "Validate nested cycle relationships",
             ]
             if conflicting_values:
                 suggestions.append("Use consistent parameter values across cycle group")
-        
+
         super().__init__(
             message,
-            error_code=kwargs.get('error_code', 'CYCLE_VALID_001'),
+            error_code=kwargs.get("error_code", "CYCLE_VALID_001"),
             context=context,
             suggestions=suggestions,
-            documentation_url="https://docs.kailash.ai/cycles/validation"
+            documentation_url="https://docs.kailash.ai/cycles/validation",
         )
 
 
@@ -366,7 +370,7 @@ class CycleExecutionError(CycleException):
         max_iterations: Optional[int] = None,
         timeout_seconds: Optional[float] = None,
         memory_usage_mb: Optional[int] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize cycle execution error.
@@ -380,49 +384,59 @@ class CycleExecutionError(CycleException):
             memory_usage_mb (int, optional): Current memory usage
             **kwargs: Additional arguments for base exception
         """
-        context = kwargs.get('context', {})
-        suggestions = kwargs.get('suggestions', [])
-        
+        context = kwargs.get("context", {})
+        suggestions = kwargs.get("suggestions", [])
+
         # Add execution-specific context
         if cycle_id:
-            context['cycle_id'] = cycle_id
+            context["cycle_id"] = cycle_id
         if current_iteration is not None:
-            context['current_iteration'] = current_iteration
+            context["current_iteration"] = current_iteration
         if max_iterations is not None:
-            context['max_iterations'] = max_iterations
+            context["max_iterations"] = max_iterations
         if timeout_seconds is not None:
-            context['timeout_seconds'] = timeout_seconds
+            context["timeout_seconds"] = timeout_seconds
         if memory_usage_mb is not None:
-            context['memory_usage_mb'] = memory_usage_mb
-        
+            context["memory_usage_mb"] = memory_usage_mb
+
         # Generate execution-specific suggestions
         if not suggestions:
             suggestions = []
-            if current_iteration and max_iterations and current_iteration >= max_iterations:
-                suggestions.extend([
-                    "Increase max_iterations if more iterations are needed",
-                    "Add or improve convergence_check for early termination",
-                    "Review cycle logic for efficiency improvements"
-                ])
+            if (
+                current_iteration
+                and max_iterations
+                and current_iteration >= max_iterations
+            ):
+                suggestions.extend(
+                    [
+                        "Increase max_iterations if more iterations are needed",
+                        "Add or improve convergence_check for early termination",
+                        "Review cycle logic for efficiency improvements",
+                    ]
+                )
             if timeout_seconds:
-                suggestions.extend([
-                    "Increase timeout limit if legitimate long execution is expected",
-                    "Optimize node processing for faster execution",
-                    "Consider breaking into smaller cycles"
-                ])
+                suggestions.extend(
+                    [
+                        "Increase timeout limit if legitimate long execution is expected",
+                        "Optimize node processing for faster execution",
+                        "Consider breaking into smaller cycles",
+                    ]
+                )
             if memory_usage_mb:
-                suggestions.extend([
-                    "Increase memory_limit if more memory is needed",
-                    "Optimize data handling to reduce memory usage",
-                    "Consider streaming or chunked processing"
-                ])
-        
+                suggestions.extend(
+                    [
+                        "Increase memory_limit if more memory is needed",
+                        "Optimize data handling to reduce memory usage",
+                        "Consider streaming or chunked processing",
+                    ]
+                )
+
         super().__init__(
             message,
-            error_code=kwargs.get('error_code', 'CYCLE_EXEC_001'),
+            error_code=kwargs.get("error_code", "CYCLE_EXEC_001"),
             context=context,
             suggestions=suggestions,
-            documentation_url="https://docs.kailash.ai/cycles/execution"
+            documentation_url="https://docs.kailash.ai/cycles/execution",
         )
 
 
@@ -455,7 +469,7 @@ class CycleConvergenceError(CycleException):
         evaluation_error: Optional[str] = None,
         available_variables: Optional[List[str]] = None,
         cycle_data: Optional[Dict[str, Any]] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize cycle convergence error.
@@ -468,46 +482,48 @@ class CycleConvergenceError(CycleException):
             cycle_data (Dict[str, Any], optional): Current cycle data
             **kwargs: Additional arguments for base exception
         """
-        context = kwargs.get('context', {})
-        suggestions = kwargs.get('suggestions', [])
-        
+        context = kwargs.get("context", {})
+        suggestions = kwargs.get("suggestions", [])
+
         # Add convergence-specific context
         if convergence_expression:
-            context['convergence_expression'] = convergence_expression
+            context["convergence_expression"] = convergence_expression
         if evaluation_error:
-            context['evaluation_error'] = evaluation_error
+            context["evaluation_error"] = evaluation_error
         if available_variables:
-            context['available_variables'] = available_variables
+            context["available_variables"] = available_variables
         if cycle_data:
-            context['cycle_data'] = {k: str(v)[:100] for k, v in cycle_data.items()}  # Truncate for readability
-        
+            context["cycle_data"] = {
+                k: str(v)[:100] for k, v in cycle_data.items()
+            }  # Truncate for readability
+
         # Generate convergence-specific suggestions
         if not suggestions:
             suggestions = [
                 "Check convergence expression syntax for typos",
                 "Ensure all referenced variables exist in cycle output",
                 "Use simple comparison operators (>, <, ==, >=, <=)",
-                "Avoid complex logic or function calls in expressions"
+                "Avoid complex logic or function calls in expressions",
             ]
             if available_variables:
-                suggestions.append(f"Available variables: {', '.join(available_variables)}")
+                suggestions.append(
+                    f"Available variables: {', '.join(available_variables)}"
+                )
             if convergence_expression and evaluation_error:
                 suggestions.append("Test convergence expression with sample data")
-        
+
         super().__init__(
             message,
-            error_code=kwargs.get('error_code', 'CYCLE_CONV_001'),
+            error_code=kwargs.get("error_code", "CYCLE_CONV_001"),
             context=context,
             suggestions=suggestions,
-            documentation_url="https://docs.kailash.ai/cycles/convergence"
+            documentation_url="https://docs.kailash.ai/cycles/convergence",
         )
 
 
 # Utility functions for enhanced error reporting
 def create_configuration_error(
-    issue: str,
-    cycle_id: Optional[str] = None,
-    **invalid_params
+    issue: str, cycle_id: Optional[str] = None, **invalid_params
 ) -> CycleConfigurationError:
     """
     Create a standardized configuration error with common suggestions.
@@ -528,9 +544,7 @@ def create_configuration_error(
         ... )
     """
     return CycleConfigurationError(
-        message=issue,
-        cycle_id=cycle_id,
-        invalid_params=invalid_params
+        message=issue, cycle_id=cycle_id, invalid_params=invalid_params
     )
 
 
@@ -538,7 +552,7 @@ def create_connection_error(
     issue: str,
     source_node: Optional[str] = None,
     target_node: Optional[str] = None,
-    available_nodes: Optional[List[str]] = None
+    available_nodes: Optional[List[str]] = None,
 ) -> CycleConnectionError:
     """
     Create a standardized connection error with node context.
@@ -563,7 +577,7 @@ def create_connection_error(
         message=issue,
         source_node=source_node,
         target_node=target_node,
-        available_nodes=available_nodes
+        available_nodes=available_nodes,
     )
 
 
@@ -571,7 +585,7 @@ def create_execution_error(
     issue: str,
     cycle_id: Optional[str] = None,
     current_iteration: Optional[int] = None,
-    max_iterations: Optional[int] = None
+    max_iterations: Optional[int] = None,
 ) -> CycleExecutionError:
     """
     Create a standardized execution error with runtime context.
@@ -597,5 +611,5 @@ def create_execution_error(
         message=issue,
         cycle_id=cycle_id,
         current_iteration=current_iteration,
-        max_iterations=max_iterations
-    )
+        max_iterations=max_iterations,
+    )