runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/common/error_handling.py

@@ -19,7 +19,7 @@ from .enhanced_exception_handler import (
     EnterpriseExceptionHandler,
     ErrorContext,
     create_exception_handler,
-    enhanced_error_handling
+    enhanced_error_handling,
 )
 
 
@@ -42,13 +42,14 @@ def handle_aws_errors(module_name: str = "runbooks", enable_recovery: bool = Tru
         def my_aws_operation(profile=None, region=None, **kwargs):
             # Your AWS operation code here
     """
+
     def decorator(f: Callable) -> Callable:
         @wraps(f)
         def wrapper(*args, **kwargs):
             # Extract common parameters for error context
-            profile = kwargs.get('profile')
-            region = kwargs.get('region', 'us-east-1')
-            operation = kwargs.get('operation', f.__name__)
+            profile = kwargs.get("profile")
+            region = kwargs.get("region", "us-east-1")
+            operation = kwargs.get("operation", f.__name__)
 
             # Create error context
             context = ErrorContext(
@@ -56,7 +57,7 @@ def handle_aws_errors(module_name: str = "runbooks", enable_recovery: bool = Tru
                 operation=operation,
                 aws_profile=profile,
                 aws_region=region,
-                user_context=kwargs
+                user_context=kwargs,
             )
 
             # Create exception handler
@@ -66,31 +67,31 @@ def handle_aws_errors(module_name: str = "runbooks", enable_recovery: bool = Tru
                 return f(*args, **kwargs)
 
             except ClientError as e:
-                error_code = e.response.get('Error', {}).get('Code', 'Unknown')
-                service = e.operation_name if hasattr(e, 'operation_name') else 'AWS'
+                error_code = e.response.get("Error", {}).get("Code", "Unknown")
+                service = e.operation_name if hasattr(e, "operation_name") else "AWS"
 
                 # Handle specific AWS errors with targeted guidance
-                if error_code == 'ExpiredToken':
+                if error_code == "ExpiredToken":
                     print_error("AWS SSO token expired")
                     profile_name = profile or "your-profile"
                     print_info(f"Run: [bold green]aws sso login --profile {profile_name}[/]")
                     sys.exit(1)
 
-                elif error_code in ['AccessDenied', 'UnauthorizedOperation', 'Forbidden']:
+                elif error_code in ["AccessDenied", "UnauthorizedOperation", "Forbidden"]:
                     print_error(f"Access denied: {e.response['Error']['Message']}")
                     print_warning("Check IAM permissions for this operation")
 
                     # Provide profile recommendations
-                    if operation in ['finops', 'cost-analysis']:
+                    if operation in ["finops", "cost-analysis"]:
                         print_info("Try using billing profile: [bold green]--profile BILLING_PROFILE[/]")
-                    elif operation in ['inventory', 'organizations']:
+                    elif operation in ["inventory", "organizations"]:
                         print_info("Try using management profile: [bold green]--profile MANAGEMENT_PROFILE[/]")
-                    elif operation in ['operate', 'resource-management']:
+                    elif operation in ["operate", "resource-management"]:
                         print_info("Try using ops profile: [bold green]--profile CENTRALISED_OPS_PROFILE[/]")
 
                     sys.exit(1)
 
-                elif error_code in ['Throttling', 'ThrottlingException', 'RequestLimitExceeded']:
+                elif error_code in ["Throttling", "ThrottlingException", "RequestLimitExceeded"]:
                     print_warning(f"AWS API throttling detected: {error_code}")
                     print_info("Implementing automatic retry with backoff...")
                     time.sleep(2)  # Basic backoff
@@ -116,11 +117,12 @@ def handle_aws_errors(module_name: str = "runbooks", enable_recovery: bool = Tru
 
             except Exception as e:
                 print_error(f"Unexpected error in {operation}: {str(e)}")
-                if kwargs.get('debug') or kwargs.get('verbose'):
+                if kwargs.get("debug") or kwargs.get("verbose"):
                     console.print_exception()
                 sys.exit(1)
 
         return wrapper
+
     return decorator
 
 
@@ -140,11 +142,12 @@ def handle_performance_errors(target_seconds: int = 30, module_name: str = "runb
         def my_operation(**kwargs):
             # Your operation code here
     """
+
     def decorator(f: Callable) -> Callable:
         @wraps(f)
         def wrapper(*args, **kwargs):
             start_time = time.time()
-            operation = kwargs.get('operation', f.__name__)
+            operation = kwargs.get("operation", f.__name__)
 
             try:
                 result = f(*args, **kwargs)
@@ -168,10 +171,10 @@ def handle_performance_errors(target_seconds: int = 30, module_name: str = "runb
                             module_name=module_name,
                             operation=operation,
                             performance_context={
-                                'execution_time': execution_time,
-                                'target_seconds': target_seconds,
-                                'performance_ratio': execution_time / target_seconds
-                            }
+                                "execution_time": execution_time,
+                                "target_seconds": target_seconds,
+                                "performance_ratio": execution_time / target_seconds,
+                            },
                         )
 
                         handler = create_exception_handler(module_name)
@@ -185,6 +188,7 @@ def handle_performance_errors(target_seconds: int = 30, module_name: str = "runb
                 raise
 
         return wrapper
+
     return decorator
 
 
@@ -200,6 +204,7 @@ def handle_validation_errors(f: Callable) -> Callable:
         def my_validation_function(data, **kwargs):
             # Your validation code here
     """
+
     @wraps(f)
     def wrapper(*args, **kwargs):
         try:
@@ -208,15 +213,15 @@ def handle_validation_errors(f: Callable) -> Callable:
         except (ValueError, TypeError) as e:
             error_msg = str(e)
 
-            if 'profile' in error_msg.lower():
+            if "profile" in error_msg.lower():
                 print_error(f"Profile validation error: {error_msg}")
                 print_info("Check available profiles: [bold green]aws configure list-profiles[/]")
 
-            elif 'region' in error_msg.lower():
+            elif "region" in error_msg.lower():
                 print_error(f"Region validation error: {error_msg}")
                 print_info("Use valid AWS region like: [bold green]us-east-1, us-west-2, eu-west-1[/]")
 
-            elif 'format' in error_msg.lower():
+            elif "format" in error_msg.lower():
                 print_error(f"Format validation error: {error_msg}")
                 print_info("Supported formats: [bold green]json, csv, table, pdf, markdown[/]")
 
@@ -233,8 +238,7 @@ def handle_validation_errors(f: Callable) -> Callable:
     return wrapper
 
 
-def graceful_degradation(fallback_function: Optional[Callable] = None,
-                        enable_fallback: bool = True):
+def graceful_degradation(fallback_function: Optional[Callable] = None, enable_fallback: bool = True):
     """
     Decorator for graceful degradation with fallback operations.
 
@@ -258,10 +262,11 @@ def graceful_degradation(fallback_function: Optional[Callable] = None,
         def fallback_operation(**kwargs):
             # Simpler fallback version
     """
+
     def decorator(f: Callable) -> Callable:
         @wraps(f)
         def wrapper(*args, **kwargs):
-            operation = kwargs.get('operation', f.__name__)
+            operation = kwargs.get("operation", f.__name__)
 
             try:
                 print_info(f"🚀 Attempting primary operation: {operation}")
@@ -306,6 +311,7 @@ def graceful_degradation(fallback_function: Optional[Callable] = None,
                 raise primary_error
 
         return wrapper
+
     return decorator
 
 
@@ -322,6 +328,7 @@ def enterprise_error_context(module_name: str):
             ctx.set_profile("BILLING_PROFILE")
             # Your operation code here
     """
+
     class EnterpriseErrorContext:
         def __init__(self, module_name: str):
             self.module_name = module_name
@@ -345,18 +352,11 @@ def enterprise_error_context(module_name: str):
 
         def __exit__(self, exc_type, exc_value, traceback):
             if exc_value is not None:
-                enhanced_error = self.handler.handle_exception(
-                    exc_value,
-                    self.context,
-                    {'context_manager': True}
-                )
+                enhanced_error = self.handler.handle_exception(exc_value, self.context, {"context_manager": True})
 
                 # Try recovery for retryable errors
                 if enhanced_error.retry_possible:
-                    recovery_success = self.handler.create_error_recovery_workflow(
-                        enhanced_error,
-                        interactive=False
-                    )
+                    recovery_success = self.handler.create_error_recovery_workflow(enhanced_error, interactive=False)
                     if recovery_success:
                         return True  # Suppress exception
 
@@ -381,8 +381,9 @@ def validate_aws_profile(profile: str) -> bool:
     """
     try:
         import boto3
+
         session = boto3.Session(profile_name=profile)
-        sts = session.client('sts')
+        sts = session.client("sts")
         identity = sts.get_caller_identity()
         print_success(f"Profile validation successful: {profile}")
         print_info(f"Account: {identity.get('Account', 'Unknown')}")
@@ -400,7 +401,7 @@ def validate_aws_profile(profile: str) -> bool:
         sys.exit(1)
 
 
-def check_aws_connectivity(region: str = 'us-east-1') -> bool:
+def check_aws_connectivity(region: str = "us-east-1") -> bool:
     """
     Check basic AWS connectivity and service availability.
 
@@ -412,8 +413,9 @@ def check_aws_connectivity(region: str = 'us-east-1') -> bool:
     """
     try:
         import boto3
+
         session = boto3.Session()
-        sts = session.client('sts', region_name=region)
+        sts = session.client("sts", region_name=region)
         sts.get_caller_identity()
         print_success(f"AWS connectivity verified: {region}")
         return True
@@ -421,4 +423,4 @@ def check_aws_connectivity(region: str = 'us-east-1') -> bool:
     except Exception as e:
         print_warning(f"AWS connectivity issue: {str(e)}")
         print_info("Check internet connection and AWS service status")
-        return False
+        return False

runbooks/common/lazy_loader.py

@@ -5,7 +5,7 @@ This module implements deferred initialization to eliminate startup overhead
 for basic CLI operations like --help and --version.
 
 Performance Goals:
-- Basic CLI operations < 0.5s 
+- Basic CLI operations < 0.5s
 - Defer AWS/MCP initialization until needed
 - Clean startup without warning pollution
 """
@@ -19,21 +19,21 @@ import sys
 
 class LazyLoader:
     """Thread-safe lazy loader for expensive imports and initializations."""
-    
+
     def __init__(self):
         self._cache: Dict[str, Any] = {}
         self._lock = threading.Lock()
-        
+
     def get_or_load(self, key: str, loader_func: Callable[[], Any]) -> Any:
         """Get cached value or load it if not present."""
         if key in self._cache:
             return self._cache[key]
-            
+
         with self._lock:
             # Double-check pattern
             if key in self._cache:
                 return self._cache[key]
-                
+
             self._cache[key] = loader_func()
             return self._cache[key]
 
@@ -44,114 +44,132 @@ _lazy_loader = LazyLoader()
 
 def lazy_aws_session():
     """Lazy load AWS session creation."""
+
     def _load_aws():
         import boto3
         from runbooks.common.profile_utils import create_management_session
+
         return create_management_session()
-    
+
     return _lazy_loader.get_or_load("aws_session", _load_aws)
 
 
 def lazy_mcp_validator():
     """Lazy load MCP validator."""
+
     def _load_mcp():
         try:
             from runbooks.finops.embedded_mcp_validator import FinOpsMCPValidator
+
             return FinOpsMCPValidator()
         except ImportError:
             return None
-    
+
     return _lazy_loader.get_or_load("mcp_validator", _load_mcp)
 
 
 def lazy_rich_console():
     """Lazy load Rich console."""
+
     def _load_rich():
         try:
             from rich.console import Console
+
             return Console()
         except ImportError:
             # Fallback console
             class SimpleConsole:
                 def print(self, *args, **kwargs):
                     print(*args)
+
             return SimpleConsole()
-    
+
     return _lazy_loader.get_or_load("rich_console", _load_rich)
 
 
 def lazy_performance_monitor():
     """Lazy load performance monitoring."""
+
     def _load_monitor():
         from runbooks.common.performance_monitor import get_performance_benchmark
+
         return get_performance_benchmark
-    
+
     return _lazy_loader.get_or_load("performance_monitor", _load_monitor)
 
 
 def lazy_pricing_api():
     """Lazy load pricing API without startup warnings."""
+
     def _load_pricing():
         try:
             from runbooks.common.aws_pricing_api import PricingAPI
+
             return PricingAPI()
         except Exception:
             # Return fallback pricing without warnings during basic operations
             class FallbackPricing:
                 def get_nat_gateway_price(self, region="us-east-1"):
                     return 32.4  # Standard fallback rate
+
             return FallbackPricing()
-    
+
     return _lazy_loader.get_or_load("pricing_api", _load_pricing)
 
 
 def lazy_inventory_collector():
     """Lazy load inventory collector."""
+
     def _load_collector():
         from runbooks.inventory.core.collector import InventoryCollector
+
         return InventoryCollector
-    
+
     return _lazy_loader.get_or_load("inventory_collector", _load_collector)
 
 
 def lazy_import(module_name: str, attribute: Optional[str] = None):
     """Lazy import a module or module attribute."""
     cache_key = f"{module_name}.{attribute}" if attribute else module_name
-    
+
     def _load_module():
         module = importlib.import_module(module_name)
         if attribute:
             return getattr(module, attribute)
         return module
-    
+
     return _lazy_loader.get_or_load(cache_key, _load_module)
 
 
 def requires_aws(func):
     """Decorator to ensure AWS session is loaded before function execution."""
+
     @wraps(func)
     def wrapper(*args, **kwargs):
         lazy_aws_session()  # Ensure AWS is loaded
         return func(*args, **kwargs)
+
     return wrapper
 
 
 def requires_mcp(func):
     """Decorator to ensure MCP validator is loaded before function execution."""
+
     @wraps(func)
     def wrapper(*args, **kwargs):
         lazy_mcp_validator()  # Ensure MCP is loaded
         return func(*args, **kwargs)
+
     return wrapper
 
 
 def fast_startup_mode() -> bool:
     """Check if we're in fast startup mode (basic operations only)."""
     import sys
-    
+
     # Basic operations that should be fast
-    fast_operations = {'--help', '-h', '--version', '-V', 'help'}
-    
+    fast_operations = {"--help", "-h", "--version", "-V", "help"}
+
     # Check if any CLI args match fast operations
     return any(arg in fast_operations for arg in sys.argv)
 
@@ -171,16 +189,16 @@ def defer_expensive_imports():
     # Only defer if we're not in fast startup mode
     if fast_startup_mode():
         return
-        
+
     # Defer expensive imports for basic operations
     modules_to_defer = [
-        'runbooks.finops.embedded_mcp_validator',
-        'runbooks.common.aws_pricing_api',
-        'runbooks.inventory.core.collector',
-        'runbooks.cfat.runner',
+        "runbooks.finops.embedded_mcp_validator",
+        "runbooks.common.aws_pricing_api",
+        "runbooks.inventory.core.collector",
+        "runbooks.cfat.runner",
     ]
-    
+
     for module in modules_to_defer:
         if module in sys.modules:
             # Replace with lazy loader
-            sys.modules[module] = lazy_import(module)
+            sys.modules[module] = lazy_import(module)