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

runbooks/finops/reservation_optimizer.py

@@ -9,7 +9,7 @@ Technical Foundation: Enterprise-grade RI analysis across EC2, RDS, ElastiCache,
 
 This module provides comprehensive Reserved Instance optimization analysis following proven FinOps patterns:
 - Multi-service resource analysis (EC2, RDS, ElastiCache, Redshift, OpenSearch)
-- Historical usage pattern analysis for RI sizing recommendations  
+- Historical usage pattern analysis for RI sizing recommendations
 - Financial modeling with break-even analysis and ROI calculations
 - Coverage optimization across different RI terms and payment options
 - Cross-account RI sharing strategy for enterprise organizations
@@ -25,43 +25,55 @@ Strategic Alignment:
 import asyncio
 import logging
 import time
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple
 from dataclasses import dataclass
+from datetime import datetime, timedelta
 from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 import click
 from botocore.exceptions import ClientError, NoCredentialsError
 from pydantic import BaseModel, Field
 
+from ..common.profile_utils import get_profile_for_operation
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel, STATUS_INDICATORS
+    STATUS_INDICATORS,
+    console,
+    create_panel,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    print_warning,
 )
-from .embedded_mcp_validator import EmbeddedMCPValidator
-from ..common.profile_utils import get_profile_for_operation
+from .mcp_validator import EmbeddedMCPValidator
 
 logger = logging.getLogger(__name__)
 
 
 class RIService(str, Enum):
     """AWS services that support Reserved Instances."""
+
     EC2 = "ec2"
     RDS = "rds"
     ELASTICACHE = "elasticache"
     REDSHIFT = "redshift"
     OPENSEARCH = "opensearch"
-    
+
 
 class RITerm(str, Enum):
     """Reserved Instance term lengths."""
+
     ONE_YEAR = "1yr"
     THREE_YEAR = "3yr"
 
 
 class RIPaymentOption(str, Enum):
     """Reserved Instance payment options."""
+
     NO_UPFRONT = "no_upfront"
     PARTIAL_UPFRONT = "partial_upfront"
     ALL_UPFRONT = "all_upfront"
@@ -69,27 +81,28 @@ class RIPaymentOption(str, Enum):
 
 class ResourceUsagePattern(BaseModel):
     """Resource usage pattern analysis for RI recommendations."""
+
     resource_id: str
     resource_type: str  # instance_type, db_instance_class, node_type, etc.
     service: RIService
     region: str
     availability_zone: Optional[str] = None
-    
+
     # Usage statistics over analysis period
     total_hours_running: float = 0.0
     average_daily_hours: float = 0.0
     usage_consistency_score: float = 0.0  # 0-1 consistency score
     seasonal_variation: float = 0.0  # 0-1 seasonal variation
-    
+
     # Current pricing
     on_demand_hourly_rate: float = 0.0
     current_monthly_cost: float = 0.0
     current_annual_cost: float = 0.0
-    
+
     # RI Suitability scoring
     ri_suitability_score: float = 0.0  # 0-100 RI recommendation score
     minimum_usage_threshold: float = 0.7  # 70% usage required for RI recommendation
-    
+
     analysis_period_days: int = 90
     platform: Optional[str] = None  # windows, linux for EC2
     engine: Optional[str] = None  # mysql, postgres for RDS
@@ -98,35 +111,36 @@ class ResourceUsagePattern(BaseModel):
 
 class RIRecommendation(BaseModel):
     """Reserved Instance purchase recommendation."""
+
     resource_type: str
     service: RIService
     region: str
     availability_zone: Optional[str] = None
     platform: Optional[str] = None
-    
+
     # Recommendation details
     recommended_quantity: int = 1
     ri_term: RITerm = RITerm.ONE_YEAR
     payment_option: RIPaymentOption = RIPaymentOption.PARTIAL_UPFRONT
-    
+
     # Financial analysis
     ri_upfront_cost: float = 0.0
     ri_hourly_rate: float = 0.0
     ri_effective_hourly_rate: float = 0.0  # Including upfront amortized
     on_demand_hourly_rate: float = 0.0
-    
+
     # Savings analysis
     break_even_months: float = 0.0
     first_year_savings: float = 0.0
     total_term_savings: float = 0.0
     annual_savings: float = 0.0
     roi_percentage: float = 0.0
-    
+
     # Risk assessment
     utilization_confidence: float = 0.0  # 0-1 confidence in utilization
     risk_level: str = "low"  # low, medium, high
     flexibility_impact: str = "minimal"  # minimal, moderate, significant
-    
+
     # Supporting resources
     covered_resources: List[str] = Field(default_factory=list)
     usage_justification: str = ""
@@ -134,30 +148,31 @@ class RIRecommendation(BaseModel):
 
 class RIOptimizerResults(BaseModel):
     """Complete Reserved Instance optimization analysis results."""
+
     analyzed_services: List[RIService] = Field(default_factory=list)
     analyzed_regions: List[str] = Field(default_factory=list)
-    
+
     # Resource analysis summary
     total_resources_analyzed: int = 0
     ri_suitable_resources: int = 0
     current_ri_coverage: float = 0.0  # % of resources already covered by RIs
-    
+
     # Financial summary
     total_current_on_demand_cost: float = 0.0
     total_potential_ri_cost: float = 0.0
     total_annual_savings: float = 0.0
     total_upfront_investment: float = 0.0
     portfolio_roi: float = 0.0
-    
+
     # Recommendations
     ri_recommendations: List[RIRecommendation] = Field(default_factory=list)
-    
+
     # Service breakdown
     ec2_recommendations: List[RIRecommendation] = Field(default_factory=list)
     rds_recommendations: List[RIRecommendation] = Field(default_factory=list)
     elasticache_recommendations: List[RIRecommendation] = Field(default_factory=list)
     redshift_recommendations: List[RIRecommendation] = Field(default_factory=list)
-    
+
     execution_time_seconds: float = 0.0
     mcp_validation_accuracy: float = 0.0
     analysis_timestamp: datetime = Field(default_factory=datetime.now)
@@ -166,7 +181,7 @@ class RIOptimizerResults(BaseModel):
 class ReservationOptimizer:
     """
     Reserved Instance Optimization Platform - Enterprise FinOps RI Strategy Engine
-    
+
     Following $132,720+ methodology with proven FinOps patterns targeting $3.2M-$17M annual savings:
     - Multi-service resource discovery and usage analysis
     - Historical usage pattern analysis for accurate RI sizing
@@ -176,119 +191,128 @@ class ReservationOptimizer:
     - Evidence generation for Manager/Financial/CTO executive reporting
     - Business-focused RI procurement strategy for enterprise budgeting
     """
-    
+
     def __init__(self, profile_name: Optional[str] = None, regions: Optional[List[str]] = None):
         """Initialize RI optimizer with enterprise profile support."""
         self.profile_name = profile_name
-        self.regions = regions or ['us-east-1', 'us-west-2', 'eu-west-1']
-        
+        self.regions = regions or ["us-east-1", "us-west-2", "eu-west-1"]
+
         # Initialize AWS session with profile priority system
-        self.session = boto3.Session(
-            profile_name=get_profile_for_operation("operational", profile_name)
-        )
-        
+        self.session = boto3.Session(profile_name=get_profile_for_operation("operational", profile_name))
+
         # RI analysis parameters
         self.analysis_period_days = 90  # 3 months usage analysis
         self.minimum_usage_threshold = 0.75  # 75% usage required for RI recommendation
         self.break_even_target_months = 10  # Target break-even within 10 months
-        
+
         # Service-specific pricing configurations (approximate 2024 rates)
         self.service_pricing = {
             RIService.EC2: {
-                'm5.large': {'on_demand': 0.096, 'ri_1yr_partial': {'upfront': 550, 'hourly': 0.055}},
-                'm5.xlarge': {'on_demand': 0.192, 'ri_1yr_partial': {'upfront': 1100, 'hourly': 0.11}},
-                'm5.2xlarge': {'on_demand': 0.384, 'ri_1yr_partial': {'upfront': 2200, 'hourly': 0.22}},
-                'c5.large': {'on_demand': 0.085, 'ri_1yr_partial': {'upfront': 500, 'hourly': 0.048}},
-                'c5.xlarge': {'on_demand': 0.17, 'ri_1yr_partial': {'upfront': 1000, 'hourly': 0.096}},
-                'r5.large': {'on_demand': 0.126, 'ri_1yr_partial': {'upfront': 720, 'hourly': 0.072}},
-                'r5.xlarge': {'on_demand': 0.252, 'ri_1yr_partial': {'upfront': 1440, 'hourly': 0.144}},
+                "m5.large": {"on_demand": 0.096, "ri_1yr_partial": {"upfront": 550, "hourly": 0.055}},
+                "m5.xlarge": {"on_demand": 0.192, "ri_1yr_partial": {"upfront": 1100, "hourly": 0.11}},
+                "m5.2xlarge": {"on_demand": 0.384, "ri_1yr_partial": {"upfront": 2200, "hourly": 0.22}},
+                "c5.large": {"on_demand": 0.085, "ri_1yr_partial": {"upfront": 500, "hourly": 0.048}},
+                "c5.xlarge": {"on_demand": 0.17, "ri_1yr_partial": {"upfront": 1000, "hourly": 0.096}},
+                "r5.large": {"on_demand": 0.126, "ri_1yr_partial": {"upfront": 720, "hourly": 0.072}},
+                "r5.xlarge": {"on_demand": 0.252, "ri_1yr_partial": {"upfront": 1440, "hourly": 0.144}},
             },
             RIService.RDS: {
-                'db.t3.medium': {'on_demand': 0.068, 'ri_1yr_partial': {'upfront': 390, 'hourly': 0.038}},
-                'db.m5.large': {'on_demand': 0.192, 'ri_1yr_partial': {'upfront': 1100, 'hourly': 0.11}},
-                'db.m5.xlarge': {'on_demand': 0.384, 'ri_1yr_partial': {'upfront': 2200, 'hourly': 0.22}},
-                'db.r5.large': {'on_demand': 0.24, 'ri_1yr_partial': {'upfront': 1370, 'hourly': 0.135}},
-                'db.r5.xlarge': {'on_demand': 0.48, 'ri_1yr_partial': {'upfront': 2740, 'hourly': 0.27}},
+                "db.t3.medium": {"on_demand": 0.068, "ri_1yr_partial": {"upfront": 390, "hourly": 0.038}},
+                "db.m5.large": {"on_demand": 0.192, "ri_1yr_partial": {"upfront": 1100, "hourly": 0.11}},
+                "db.m5.xlarge": {"on_demand": 0.384, "ri_1yr_partial": {"upfront": 2200, "hourly": 0.22}},
+                "db.r5.large": {"on_demand": 0.24, "ri_1yr_partial": {"upfront": 1370, "hourly": 0.135}},
+                "db.r5.xlarge": {"on_demand": 0.48, "ri_1yr_partial": {"upfront": 2740, "hourly": 0.27}},
             },
             RIService.ELASTICACHE: {
-                'cache.m5.large': {'on_demand': 0.136, 'ri_1yr_partial': {'upfront': 780, 'hourly': 0.077}},
-                'cache.r5.large': {'on_demand': 0.188, 'ri_1yr_partial': {'upfront': 1075, 'hourly': 0.106}},
-            }
+                "cache.m5.large": {"on_demand": 0.136, "ri_1yr_partial": {"upfront": 780, "hourly": 0.077}},
+                "cache.r5.large": {"on_demand": 0.188, "ri_1yr_partial": {"upfront": 1075, "hourly": 0.106}},
+            },
         }
-    
-    async def analyze_reservation_opportunities(self, services: List[RIService] = None, dry_run: bool = True) -> RIOptimizerResults:
+
+    async def analyze_reservation_opportunities(
+        self, services: List[RIService] = None, dry_run: bool = True
+    ) -> RIOptimizerResults:
         """
         Comprehensive Reserved Instance optimization analysis across AWS services.
-        
+
         Args:
             services: List of AWS services to analyze (None = all supported services)
             dry_run: Safety mode - READ-ONLY analysis only
-            
+
         Returns:
             Complete analysis results with RI recommendations and financial modeling
         """
         print_header("Reserved Instance Optimization Platform", "Enterprise Multi-Service RI Strategy Engine v1.0")
-        
+
         if not dry_run:
             print_warning("⚠️ Dry-run disabled - This optimizer is READ-ONLY analysis only")
             print_info("All RI procurement decisions require manual execution after review")
-        
+
         analysis_start_time = time.time()
         services_to_analyze = services or [RIService.EC2, RIService.RDS, RIService.ELASTICACHE]
-        
+
         try:
             with create_progress_bar() as progress:
                 # Step 1: Multi-service resource discovery
-                discovery_task = progress.add_task("Discovering resources across services...", 
-                                                 total=len(services_to_analyze) * len(self.regions))
-                usage_patterns = await self._discover_resources_multi_service(services_to_analyze, progress, discovery_task)
-                
+                discovery_task = progress.add_task(
+                    "Discovering resources across services...", total=len(services_to_analyze) * len(self.regions)
+                )
+                usage_patterns = await self._discover_resources_multi_service(
+                    services_to_analyze, progress, discovery_task
+                )
+
                 if not usage_patterns:
                     print_warning("No suitable resources found for RI analysis")
                     return RIOptimizerResults(
                         analyzed_services=services_to_analyze,
                         analyzed_regions=self.regions,
                         analysis_timestamp=datetime.now(),
-                        execution_time_seconds=time.time() - analysis_start_time
+                        execution_time_seconds=time.time() - analysis_start_time,
                     )
-                
+
                 # Step 2: Usage pattern analysis
                 usage_task = progress.add_task("Analyzing usage patterns...", total=len(usage_patterns))
                 analyzed_patterns = await self._analyze_usage_patterns(usage_patterns, progress, usage_task)
-                
+
                 # Step 3: RI suitability assessment
                 suitability_task = progress.add_task("Assessing RI suitability...", total=len(analyzed_patterns))
                 suitable_resources = await self._assess_ri_suitability(analyzed_patterns, progress, suitability_task)
-                
+
                 # Step 4: Financial modeling and recommendations
                 modeling_task = progress.add_task("Financial modeling...", total=len(suitable_resources))
                 recommendations = await self._generate_ri_recommendations(suitable_resources, progress, modeling_task)
-                
+
                 # Step 5: Portfolio optimization
                 optimization_task = progress.add_task("Optimizing RI portfolio...", total=1)
-                optimized_recommendations = await self._optimize_ri_portfolio(recommendations, progress, optimization_task)
-                
+                optimized_recommendations = await self._optimize_ri_portfolio(
+                    recommendations, progress, optimization_task
+                )
+
                 # Step 6: MCP validation
                 validation_task = progress.add_task("MCP validation...", total=1)
                 mcp_accuracy = await self._validate_with_mcp(optimized_recommendations, progress, validation_task)
-                
+
             # Compile comprehensive results
-            results = self._compile_results(usage_patterns, optimized_recommendations, mcp_accuracy, analysis_start_time, services_to_analyze)
-            
+            results = self._compile_results(
+                usage_patterns, optimized_recommendations, mcp_accuracy, analysis_start_time, services_to_analyze
+            )
+
             # Display executive summary
             self._display_executive_summary(results)
-            
+
             return results
-            
+
         except Exception as e:
             print_error(f"Reserved Instance optimization analysis failed: {e}")
             logger.error(f"RI analysis error: {e}", exc_info=True)
             raise
-    
-    async def _discover_resources_multi_service(self, services: List[RIService], progress, task_id) -> List[ResourceUsagePattern]:
+
+    async def _discover_resources_multi_service(
+        self, services: List[RIService], progress, task_id
+    ) -> List[ResourceUsagePattern]:
         """Discover resources across multiple AWS services for RI analysis."""
         usage_patterns = []
-        
+
         for service in services:
             for region in self.regions:
                 try:
@@ -304,272 +328,294 @@ class ReservationOptimizer:
                     elif service == RIService.REDSHIFT:
                         patterns = await self._discover_redshift_resources(region)
                         usage_patterns.extend(patterns)
-                    
-                    print_info(f"Service {service.value} in {region}: {len([p for p in usage_patterns if p.region == region and p.service == service])} resources discovered")
-                    
+
+                    print_info(
+                        f"Service {service.value} in {region}: {len([p for p in usage_patterns if p.region == region and p.service == service])} resources discovered"
+                    )
+
                 except ClientError as e:
                     print_warning(f"Service {service.value} in {region}: Access denied - {e.response['Error']['Code']}")
                 except Exception as e:
                     print_error(f"Service {service.value} in {region}: Discovery error - {str(e)}")
-                    
+
                 progress.advance(task_id)
-        
+
         return usage_patterns
-    
+
     async def _discover_ec2_resources(self, region: str) -> List[ResourceUsagePattern]:
         """Discover EC2 instances for RI analysis."""
         patterns = []
-        
+
         try:
-            ec2_client = self.session.client('ec2', region_name=region)
-            
-            paginator = ec2_client.get_paginator('describe_instances')
+            ec2_client = self.session.client("ec2", region_name=region)
+
+            paginator = ec2_client.get_paginator("describe_instances")
             page_iterator = paginator.paginate()
-            
+
             for page in page_iterator:
-                for reservation in page.get('Reservations', []):
-                    for instance in reservation.get('Instances', []):
+                for reservation in page.get("Reservations", []):
+                    for instance in reservation.get("Instances", []):
                         # Skip terminated instances
-                        if instance.get('State', {}).get('Name') == 'terminated':
+                        if instance.get("State", {}).get("Name") == "terminated":
                             continue
-                            
+
                         # Extract tags
-                        tags = {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}
-                        
+                        tags = {tag["Key"]: tag["Value"] for tag in instance.get("Tags", [])}
+
                         # Get pricing information
-                        instance_type = instance['InstanceType']
+                        instance_type = instance["InstanceType"]
                         pricing = self.service_pricing.get(RIService.EC2, {}).get(instance_type, {})
-                        on_demand_rate = pricing.get('on_demand', 0.1)  # Default fallback
-                        
-                        patterns.append(ResourceUsagePattern(
-                            resource_id=instance['InstanceId'],
-                            resource_type=instance_type,
-                            service=RIService.EC2,
-                            region=region,
-                            availability_zone=instance['Placement']['AvailabilityZone'],
-                            on_demand_hourly_rate=on_demand_rate,
-                            platform=instance.get('Platform', 'linux'),
-                            tags=tags,
-                            analysis_period_days=self.analysis_period_days
-                        ))
-                        
+                        on_demand_rate = pricing.get("on_demand", 0.1)  # Default fallback
+
+                        patterns.append(
+                            ResourceUsagePattern(
+                                resource_id=instance["InstanceId"],
+                                resource_type=instance_type,
+                                service=RIService.EC2,
+                                region=region,
+                                availability_zone=instance["Placement"]["AvailabilityZone"],
+                                on_demand_hourly_rate=on_demand_rate,
+                                platform=instance.get("Platform", "linux"),
+                                tags=tags,
+                                analysis_period_days=self.analysis_period_days,
+                            )
+                        )
+
         except Exception as e:
             logger.warning(f"EC2 discovery failed in {region}: {e}")
-        
+
         return patterns
-    
+
     async def _discover_rds_resources(self, region: str) -> List[ResourceUsagePattern]:
         """Discover RDS instances for RI analysis."""
         patterns = []
-        
+
         try:
-            rds_client = self.session.client('rds', region_name=region)
-            
-            paginator = rds_client.get_paginator('describe_db_instances')
+            rds_client = self.session.client("rds", region_name=region)
+
+            paginator = rds_client.get_paginator("describe_db_instances")
             page_iterator = paginator.paginate()
-            
+
             for page in page_iterator:
-                for db_instance in page.get('DBInstances', []):
+                for db_instance in page.get("DBInstances", []):
                     # Skip instances that are not running/available
-                    if db_instance.get('DBInstanceStatus') not in ['available', 'storage-optimization']:
+                    if db_instance.get("DBInstanceStatus") not in ["available", "storage-optimization"]:
                         continue
-                    
+
                     # Get pricing information
-                    instance_class = db_instance['DBInstanceClass']
+                    instance_class = db_instance["DBInstanceClass"]
                     pricing = self.service_pricing.get(RIService.RDS, {}).get(instance_class, {})
-                    on_demand_rate = pricing.get('on_demand', 0.2)  # Default fallback
-                    
-                    patterns.append(ResourceUsagePattern(
-                        resource_id=db_instance['DBInstanceIdentifier'],
-                        resource_type=instance_class,
-                        service=RIService.RDS,
-                        region=region,
-                        availability_zone=db_instance.get('AvailabilityZone'),
-                        on_demand_hourly_rate=on_demand_rate,
-                        engine=db_instance.get('Engine'),
-                        analysis_period_days=self.analysis_period_days
-                    ))
-                    
+                    on_demand_rate = pricing.get("on_demand", 0.2)  # Default fallback
+
+                    patterns.append(
+                        ResourceUsagePattern(
+                            resource_id=db_instance["DBInstanceIdentifier"],
+                            resource_type=instance_class,
+                            service=RIService.RDS,
+                            region=region,
+                            availability_zone=db_instance.get("AvailabilityZone"),
+                            on_demand_hourly_rate=on_demand_rate,
+                            engine=db_instance.get("Engine"),
+                            analysis_period_days=self.analysis_period_days,
+                        )
+                    )
+
         except Exception as e:
             logger.warning(f"RDS discovery failed in {region}: {e}")
-        
+
         return patterns
-    
+
     async def _discover_elasticache_resources(self, region: str) -> List[ResourceUsagePattern]:
         """Discover ElastiCache clusters for RI analysis."""
         patterns = []
-        
+
         try:
-            elasticache_client = self.session.client('elasticache', region_name=region)
-            
+            elasticache_client = self.session.client("elasticache", region_name=region)
+
             # Discover Redis clusters
             response = elasticache_client.describe_cache_clusters()
-            for cluster in response.get('CacheClusters', []):
-                if cluster.get('CacheClusterStatus') != 'available':
+            for cluster in response.get("CacheClusters", []):
+                if cluster.get("CacheClusterStatus") != "available":
                     continue
-                
-                node_type = cluster.get('CacheNodeType')
+
+                node_type = cluster.get("CacheNodeType")
                 pricing = self.service_pricing.get(RIService.ELASTICACHE, {}).get(node_type, {})
-                on_demand_rate = pricing.get('on_demand', 0.15)  # Default fallback
-                
-                patterns.append(ResourceUsagePattern(
-                    resource_id=cluster['CacheClusterId'],
-                    resource_type=node_type,
-                    service=RIService.ELASTICACHE,
-                    region=region,
-                    on_demand_hourly_rate=on_demand_rate,
-                    engine=cluster.get('Engine'),
-                    analysis_period_days=self.analysis_period_days
-                ))
-                
+                on_demand_rate = pricing.get("on_demand", 0.15)  # Default fallback
+
+                patterns.append(
+                    ResourceUsagePattern(
+                        resource_id=cluster["CacheClusterId"],
+                        resource_type=node_type,
+                        service=RIService.ELASTICACHE,
+                        region=region,
+                        on_demand_hourly_rate=on_demand_rate,
+                        engine=cluster.get("Engine"),
+                        analysis_period_days=self.analysis_period_days,
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"ElastiCache discovery failed in {region}: {e}")
-        
+
         return patterns
-    
+
     async def _discover_redshift_resources(self, region: str) -> List[ResourceUsagePattern]:
         """Discover Redshift clusters for RI analysis."""
         patterns = []
-        
+
         try:
-            redshift_client = self.session.client('redshift', region_name=region)
-            
+            redshift_client = self.session.client("redshift", region_name=region)
+
             response = redshift_client.describe_clusters()
-            for cluster in response.get('Clusters', []):
-                if cluster.get('ClusterStatus') != 'available':
+            for cluster in response.get("Clusters", []):
+                if cluster.get("ClusterStatus") != "available":
                     continue
-                
-                node_type = cluster.get('NodeType')
+
+                node_type = cluster.get("NodeType")
                 # Redshift pricing is more complex, using simplified estimate
                 on_demand_rate = 0.25  # Approximate rate per node per hour
-                
-                patterns.append(ResourceUsagePattern(
-                    resource_id=cluster['ClusterIdentifier'],
-                    resource_type=node_type,
-                    service=RIService.REDSHIFT,
-                    region=region,
-                    on_demand_hourly_rate=on_demand_rate,
-                    analysis_period_days=self.analysis_period_days
-                ))
-                
+
+                patterns.append(
+                    ResourceUsagePattern(
+                        resource_id=cluster["ClusterIdentifier"],
+                        resource_type=node_type,
+                        service=RIService.REDSHIFT,
+                        region=region,
+                        on_demand_hourly_rate=on_demand_rate,
+                        analysis_period_days=self.analysis_period_days,
+                    )
+                )
+
         except Exception as e:
             logger.warning(f"Redshift discovery failed in {region}: {e}")
-        
+
         return patterns
-    
-    async def _analyze_usage_patterns(self, patterns: List[ResourceUsagePattern], progress, task_id) -> List[ResourceUsagePattern]:
+
+    async def _analyze_usage_patterns(
+        self, patterns: List[ResourceUsagePattern], progress, task_id
+    ) -> List[ResourceUsagePattern]:
         """Analyze resource usage patterns via CloudWatch metrics."""
         analyzed_patterns = []
         end_time = datetime.utcnow()
         start_time = end_time - timedelta(days=self.analysis_period_days)
-        
+
         for pattern in patterns:
             try:
-                cloudwatch = self.session.client('cloudwatch', region_name=pattern.region)
-                
+                cloudwatch = self.session.client("cloudwatch", region_name=pattern.region)
+
                 # Get utilization metrics based on service type
                 if pattern.service == RIService.EC2:
-                    cpu_utilization = await self._get_ec2_utilization(cloudwatch, pattern.resource_id, start_time, end_time)
+                    cpu_utilization = await self._get_ec2_utilization(
+                        cloudwatch, pattern.resource_id, start_time, end_time
+                    )
                     usage_hours = self._calculate_usage_hours(cpu_utilization, self.analysis_period_days)
                 elif pattern.service == RIService.RDS:
-                    cpu_utilization = await self._get_rds_utilization(cloudwatch, pattern.resource_id, start_time, end_time)
+                    cpu_utilization = await self._get_rds_utilization(
+                        cloudwatch, pattern.resource_id, start_time, end_time
+                    )
                     usage_hours = self._calculate_usage_hours(cpu_utilization, self.analysis_period_days)
                 else:
                     # For other services, assume consistent usage pattern
                     usage_hours = self.analysis_period_days * 24 * 0.8  # 80% uptime assumption
-                
+
                 # Calculate usage statistics
                 total_possible_hours = self.analysis_period_days * 24
                 usage_percentage = usage_hours / total_possible_hours if total_possible_hours > 0 else 0
-                
+
                 # Update pattern with usage analysis
                 pattern.total_hours_running = usage_hours
                 pattern.average_daily_hours = usage_hours / self.analysis_period_days
                 pattern.usage_consistency_score = min(1.0, usage_percentage)
-                pattern.current_monthly_cost = pattern.on_demand_hourly_rate * (usage_hours / self.analysis_period_days) * 30.44 * 24
+                pattern.current_monthly_cost = (
+                    pattern.on_demand_hourly_rate * (usage_hours / self.analysis_period_days) * 30.44 * 24
+                )
                 pattern.current_annual_cost = pattern.current_monthly_cost * 12
-                
+
                 # Calculate RI suitability score
                 pattern.ri_suitability_score = self._calculate_ri_suitability_score(pattern)
-                
+
                 analyzed_patterns.append(pattern)
-                
+
             except Exception as e:
                 print_warning(f"Usage analysis failed for {pattern.resource_id}: {str(e)}")
                 # Keep pattern with default values
                 pattern.usage_consistency_score = 0.5
                 pattern.ri_suitability_score = 40.0
                 analyzed_patterns.append(pattern)
-                
+
             progress.advance(task_id)
-        
+
         return analyzed_patterns
-    
-    async def _get_ec2_utilization(self, cloudwatch, instance_id: str, start_time: datetime, end_time: datetime) -> List[float]:
+
+    async def _get_ec2_utilization(
+        self, cloudwatch, instance_id: str, start_time: datetime, end_time: datetime
+    ) -> List[float]:
         """Get EC2 instance CPU utilization from CloudWatch."""
         try:
             response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/EC2',
-                MetricName='CPUUtilization',
-                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
+                Namespace="AWS/EC2",
+                MetricName="CPUUtilization",
+                Dimensions=[{"Name": "InstanceId", "Value": instance_id}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,  # Daily data points
-                Statistics=['Average']
+                Statistics=["Average"],
             )
-            
-            return [point['Average'] for point in response.get('Datapoints', [])]
-            
+
+            return [point["Average"] for point in response.get("Datapoints", [])]
+
         except Exception as e:
             logger.warning(f"CloudWatch CPU metrics unavailable for EC2 {instance_id}: {e}")
             return []
-    
-    async def _get_rds_utilization(self, cloudwatch, db_identifier: str, start_time: datetime, end_time: datetime) -> List[float]:
+
+    async def _get_rds_utilization(
+        self, cloudwatch, db_identifier: str, start_time: datetime, end_time: datetime
+    ) -> List[float]:
         """Get RDS instance CPU utilization from CloudWatch."""
         try:
             response = cloudwatch.get_metric_statistics(
-                Namespace='AWS/RDS',
-                MetricName='CPUUtilization',
-                Dimensions=[{'Name': 'DBInstanceIdentifier', 'Value': db_identifier}],
+                Namespace="AWS/RDS",
+                MetricName="CPUUtilization",
+                Dimensions=[{"Name": "DBInstanceIdentifier", "Value": db_identifier}],
                 StartTime=start_time,
                 EndTime=end_time,
                 Period=86400,  # Daily data points
-                Statistics=['Average']
+                Statistics=["Average"],
             )
-            
-            return [point['Average'] for point in response.get('Datapoints', [])]
-            
+
+            return [point["Average"] for point in response.get("Datapoints", [])]
+
         except Exception as e:
             logger.warning(f"CloudWatch CPU metrics unavailable for RDS {db_identifier}: {e}")
             return []
-    
+
     def _calculate_usage_hours(self, utilization_data: List[float], analysis_days: int) -> float:
         """Calculate actual usage hours based on utilization data."""
         if not utilization_data:
             # No metrics available, assume moderate usage
             return analysis_days * 24 * 0.7  # 70% uptime assumption
-        
+
         # Assume instance is "in use" if CPU > 5%
         active_days = sum(1 for cpu in utilization_data if cpu > 5.0)
         total_hours = active_days * 24  # Assume full day usage when active
-        
+
         return min(total_hours, analysis_days * 24)
-    
+
     def _calculate_ri_suitability_score(self, pattern: ResourceUsagePattern) -> float:
         """Calculate RI suitability score (0-100) for resource."""
         score = 0.0
-        
+
         # Usage consistency (50% weight)
         score += pattern.usage_consistency_score * 50
-        
+
         # Resource type stability (25% weight)
-        if pattern.tags.get('Environment') in ['production', 'prod']:
+        if pattern.tags.get("Environment") in ["production", "prod"]:
             score += 25
-        elif pattern.tags.get('Environment') in ['staging', 'test']:
+        elif pattern.tags.get("Environment") in ["staging", "test"]:
             score += 10
         else:
             score += 15  # Unknown environment
-        
+
         # Cost impact (25% weight)
         if pattern.current_annual_cost > 5000:  # High cost resources
             score += 25
@@ -577,110 +623,126 @@ class ReservationOptimizer:
             score += 20
         else:
             score += 10
-        
+
         return min(100.0, score)
-    
-    async def _assess_ri_suitability(self, patterns: List[ResourceUsagePattern], progress, task_id) -> List[ResourceUsagePattern]:
+
+    async def _assess_ri_suitability(
+        self, patterns: List[ResourceUsagePattern], progress, task_id
+    ) -> List[ResourceUsagePattern]:
         """Assess which resources are suitable for Reserved Instance purchase."""
         suitable_resources = []
-        
+
         for pattern in patterns:
             try:
                 # Check if resource meets RI suitability criteria
-                if (pattern.ri_suitability_score >= 60.0 and 
-                    pattern.usage_consistency_score >= self.minimum_usage_threshold):
+                if (
+                    pattern.ri_suitability_score >= 60.0
+                    and pattern.usage_consistency_score >= self.minimum_usage_threshold
+                ):
                     suitable_resources.append(pattern)
-                    
+
             except Exception as e:
                 logger.warning(f"RI suitability assessment failed for {pattern.resource_id}: {e}")
-                
+
             progress.advance(task_id)
-        
+
         return suitable_resources
-    
-    async def _generate_ri_recommendations(self, suitable_resources: List[ResourceUsagePattern], progress, task_id) -> List[RIRecommendation]:
+
+    async def _generate_ri_recommendations(
+        self, suitable_resources: List[ResourceUsagePattern], progress, task_id
+    ) -> List[RIRecommendation]:
         """Generate Reserved Instance purchase recommendations with financial modeling."""
         recommendations = []
-        
+
         for resource in suitable_resources:
             try:
                 # Get RI pricing for resource type
                 service_pricing = self.service_pricing.get(resource.service, {})
                 type_pricing = service_pricing.get(resource.resource_type, {})
-                ri_pricing = type_pricing.get('ri_1yr_partial', {})
-                
+                ri_pricing = type_pricing.get("ri_1yr_partial", {})
+
                 if not ri_pricing:
                     progress.advance(task_id)
                     continue
-                
+
                 # Calculate financial model
-                upfront_cost = ri_pricing.get('upfront', 0)
-                ri_hourly_rate = ri_pricing.get('hourly', resource.on_demand_hourly_rate * 0.6)
-                
+                upfront_cost = ri_pricing.get("upfront", 0)
+                ri_hourly_rate = ri_pricing.get("hourly", resource.on_demand_hourly_rate * 0.6)
+
                 # Effective hourly rate including amortized upfront
                 effective_hourly_rate = ri_hourly_rate + (upfront_cost / (365.25 * 24))
-                
+
                 # Savings calculations based on actual usage
                 annual_usage_hours = resource.average_daily_hours * 365.25
                 on_demand_annual_cost = resource.on_demand_hourly_rate * annual_usage_hours
                 ri_annual_cost = upfront_cost + (ri_hourly_rate * annual_usage_hours)
                 annual_savings = on_demand_annual_cost - ri_annual_cost
-                
+
                 # Break-even analysis
                 monthly_savings = annual_savings / 12
                 break_even_months = upfront_cost / monthly_savings if monthly_savings > 0 else 999
-                
+
                 # ROI calculation
-                roi_percentage = (annual_savings / (upfront_cost + ri_hourly_rate * annual_usage_hours)) * 100 if upfront_cost > 0 else 0
-                
+                roi_percentage = (
+                    (annual_savings / (upfront_cost + ri_hourly_rate * annual_usage_hours)) * 100
+                    if upfront_cost > 0
+                    else 0
+                )
+
                 # Risk assessment
                 utilization_confidence = resource.usage_consistency_score
-                risk_level = "low" if utilization_confidence > 0.8 else ("medium" if utilization_confidence > 0.6 else "high")
-                
+                risk_level = (
+                    "low" if utilization_confidence > 0.8 else ("medium" if utilization_confidence > 0.6 else "high")
+                )
+
                 # Only recommend if financially beneficial
                 if annual_savings > 0 and break_even_months <= self.break_even_target_months:
-                    recommendations.append(RIRecommendation(
-                        resource_type=resource.resource_type,
-                        service=resource.service,
-                        region=resource.region,
-                        availability_zone=resource.availability_zone,
-                        platform=resource.platform,
-                        recommended_quantity=1,
-                        ri_term=RITerm.ONE_YEAR,
-                        payment_option=RIPaymentOption.PARTIAL_UPFRONT,
-                        ri_upfront_cost=upfront_cost,
-                        ri_hourly_rate=ri_hourly_rate,
-                        ri_effective_hourly_rate=effective_hourly_rate,
-                        on_demand_hourly_rate=resource.on_demand_hourly_rate,
-                        break_even_months=break_even_months,
-                        first_year_savings=annual_savings,
-                        total_term_savings=annual_savings,  # 1-year term
-                        annual_savings=annual_savings,
-                        roi_percentage=roi_percentage,
-                        utilization_confidence=utilization_confidence,
-                        risk_level=risk_level,
-                        flexibility_impact="minimal",
-                        covered_resources=[resource.resource_id],
-                        usage_justification=f"Resource shows {resource.usage_consistency_score*100:.1f}% consistent usage over {resource.analysis_period_days} days"
-                    ))
-                    
+                    recommendations.append(
+                        RIRecommendation(
+                            resource_type=resource.resource_type,
+                            service=resource.service,
+                            region=resource.region,
+                            availability_zone=resource.availability_zone,
+                            platform=resource.platform,
+                            recommended_quantity=1,
+                            ri_term=RITerm.ONE_YEAR,
+                            payment_option=RIPaymentOption.PARTIAL_UPFRONT,
+                            ri_upfront_cost=upfront_cost,
+                            ri_hourly_rate=ri_hourly_rate,
+                            ri_effective_hourly_rate=effective_hourly_rate,
+                            on_demand_hourly_rate=resource.on_demand_hourly_rate,
+                            break_even_months=break_even_months,
+                            first_year_savings=annual_savings,
+                            total_term_savings=annual_savings,  # 1-year term
+                            annual_savings=annual_savings,
+                            roi_percentage=roi_percentage,
+                            utilization_confidence=utilization_confidence,
+                            risk_level=risk_level,
+                            flexibility_impact="minimal",
+                            covered_resources=[resource.resource_id],
+                            usage_justification=f"Resource shows {resource.usage_consistency_score * 100:.1f}% consistent usage over {resource.analysis_period_days} days",
+                        )
+                    )
+
             except Exception as e:
                 logger.warning(f"RI recommendation generation failed for {resource.resource_id}: {e}")
-                
+
             progress.advance(task_id)
-        
+
         return recommendations
-    
-    async def _optimize_ri_portfolio(self, recommendations: List[RIRecommendation], progress, task_id) -> List[RIRecommendation]:
+
+    async def _optimize_ri_portfolio(
+        self, recommendations: List[RIRecommendation], progress, task_id
+    ) -> List[RIRecommendation]:
         """Optimize RI portfolio for maximum value and minimum risk."""
         try:
             # Sort recommendations by ROI and risk level
             optimized = sorted(recommendations, key=lambda x: (x.roi_percentage, -x.break_even_months), reverse=True)
-            
+
             # Apply portfolio constraints (simplified)
             budget_limit = 1_000_000  # $1M annual RI budget limit
             current_investment = 0
-            
+
             final_recommendations = []
             for recommendation in optimized:
                 if current_investment + recommendation.ri_upfront_cost <= budget_limit:
@@ -688,71 +750,75 @@ class ReservationOptimizer:
                     current_investment += recommendation.ri_upfront_cost
                 else:
                     break
-            
+
             progress.advance(task_id)
             return final_recommendations
-            
+
         except Exception as e:
             logger.warning(f"RI portfolio optimization failed: {e}")
             progress.advance(task_id)
             return recommendations
-    
+
     async def _validate_with_mcp(self, recommendations: List[RIRecommendation], progress, task_id) -> float:
         """Validate RI recommendations with embedded MCP validator."""
         try:
             # Prepare validation data in FinOps format
             validation_data = {
-                'total_upfront_investment': sum(rec.ri_upfront_cost for rec in recommendations),
-                'total_annual_savings': sum(rec.annual_savings for rec in recommendations),
-                'recommendations_count': len(recommendations),
-                'services_analyzed': list(set(rec.service.value for rec in recommendations)),
-                'analysis_timestamp': datetime.now().isoformat()
+                "total_upfront_investment": sum(rec.ri_upfront_cost for rec in recommendations),
+                "total_annual_savings": sum(rec.annual_savings for rec in recommendations),
+                "recommendations_count": len(recommendations),
+                "services_analyzed": list(set(rec.service.value for rec in recommendations)),
+                "analysis_timestamp": datetime.now().isoformat(),
             }
-            
+
             # Initialize MCP validator if profile is available
             if self.profile_name:
                 mcp_validator = EmbeddedMCPValidator([self.profile_name])
                 validation_results = await mcp_validator.validate_cost_data_async(validation_data)
-                accuracy = validation_results.get('total_accuracy', 0.0)
-                
+                accuracy = validation_results.get("total_accuracy", 0.0)
+
                 if accuracy >= 99.5:
                     print_success(f"MCP Validation: {accuracy:.1f}% accuracy achieved (target: ≥99.5%)")
                 else:
                     print_warning(f"MCP Validation: {accuracy:.1f}% accuracy (target: ≥99.5%)")
-                    
+
                 progress.advance(task_id)
                 return accuracy
             else:
                 print_info("MCP validation skipped - no profile specified")
                 progress.advance(task_id)
                 return 0.0
-                
+
         except Exception as e:
             print_warning(f"MCP validation failed: {str(e)}")
             progress.advance(task_id)
             return 0.0
-    
-    def _compile_results(self, usage_patterns: List[ResourceUsagePattern], 
-                        recommendations: List[RIRecommendation],
-                        mcp_accuracy: float, analysis_start_time: float,
-                        services_analyzed: List[RIService]) -> RIOptimizerResults:
+
+    def _compile_results(
+        self,
+        usage_patterns: List[ResourceUsagePattern],
+        recommendations: List[RIRecommendation],
+        mcp_accuracy: float,
+        analysis_start_time: float,
+        services_analyzed: List[RIService],
+    ) -> RIOptimizerResults:
         """Compile comprehensive RI optimization results."""
-        
+
         # Categorize recommendations by service
         ec2_recommendations = [r for r in recommendations if r.service == RIService.EC2]
         rds_recommendations = [r for r in recommendations if r.service == RIService.RDS]
         elasticache_recommendations = [r for r in recommendations if r.service == RIService.ELASTICACHE]
         redshift_recommendations = [r for r in recommendations if r.service == RIService.REDSHIFT]
-        
+
         # Calculate financial summary
         total_upfront_investment = sum(rec.ri_upfront_cost for rec in recommendations)
         total_annual_savings = sum(rec.annual_savings for rec in recommendations)
         total_current_on_demand_cost = sum(pattern.current_annual_cost for pattern in usage_patterns)
         total_potential_ri_cost = total_current_on_demand_cost - total_annual_savings
-        
+
         # Calculate portfolio ROI
         portfolio_roi = (total_annual_savings / total_upfront_investment * 100) if total_upfront_investment > 0 else 0
-        
+
         return RIOptimizerResults(
             analyzed_services=services_analyzed,
             analyzed_regions=self.regions,
@@ -771,12 +837,12 @@ class ReservationOptimizer:
             redshift_recommendations=redshift_recommendations,
             execution_time_seconds=time.time() - analysis_start_time,
             mcp_validation_accuracy=mcp_accuracy,
-            analysis_timestamp=datetime.now()
+            analysis_timestamp=datetime.now(),
         )
-    
+
     def _display_executive_summary(self, results: RIOptimizerResults) -> None:
         """Display executive summary with Rich CLI formatting."""
-        
+
         # Executive Summary Panel
         summary_content = f"""
 💼 Reserved Instance Portfolio Analysis
@@ -794,23 +860,21 @@ class ReservationOptimizer:
    • ElastiCache: {len(results.elasticache_recommendations)} recommendations
    • Redshift: {len(results.redshift_recommendations)} recommendations
 
-🌍 Regions: {', '.join(results.analyzed_regions)}
+🌍 Regions: {", ".join(results.analyzed_regions)}
 ⚡ Analysis Time: {results.execution_time_seconds:.2f}s
 ✅ MCP Accuracy: {results.mcp_validation_accuracy:.1f}%
         """
-        
-        console.print(create_panel(
-            summary_content.strip(),
-            title="🏆 Reserved Instance Portfolio Executive Summary",
-            border_style="green"
-        ))
-        
+
+        console.print(
+            create_panel(
+                summary_content.strip(), title="🏆 Reserved Instance Portfolio Executive Summary", border_style="green"
+            )
+        )
+
         # RI Recommendations Table
         if results.ri_recommendations:
-            table = create_table(
-                title="Reserved Instance Purchase Recommendations"
-            )
-            
+            table = create_table(title="Reserved Instance Purchase Recommendations")
+
             table.add_column("Service", style="cyan", no_wrap=True)
             table.add_column("Resource Type", style="dim")
             table.add_column("Region", justify="center")
@@ -819,24 +883,16 @@ class ReservationOptimizer:
             table.add_column("Break-even", justify="center")
             table.add_column("ROI", justify="right", style="blue")
             table.add_column("Risk", justify="center")
-            
+
             # Sort by annual savings (descending)
-            sorted_recommendations = sorted(
-                results.ri_recommendations, 
-                key=lambda x: x.annual_savings, 
-                reverse=True
-            )
-            
+            sorted_recommendations = sorted(results.ri_recommendations, key=lambda x: x.annual_savings, reverse=True)
+
             # Show top 20 recommendations
             display_recommendations = sorted_recommendations[:20]
-            
+
             for rec in display_recommendations:
-                risk_indicator = {
-                    "low": "🟢",
-                    "medium": "🟡",
-                    "high": "🔴"
-                }.get(rec.risk_level, "⚪")
-                
+                risk_indicator = {"low": "🟢", "medium": "🟡", "high": "🔴"}.get(rec.risk_level, "⚪")
+
                 table.add_row(
                     rec.service.value.upper(),
                     rec.resource_type,
@@ -845,17 +901,23 @@ class ReservationOptimizer:
                     format_cost(rec.annual_savings),
                     f"{rec.break_even_months:.1f} mo",
                     f"{rec.roi_percentage:.1f}%",
-                    f"{risk_indicator} {rec.risk_level}"
+                    f"{risk_indicator} {rec.risk_level}",
                 )
-            
+
             if len(sorted_recommendations) > 20:
                 table.add_row(
-                    "...", "...", "...", "...", "...", "...", "...",
-                    f"[dim]+{len(sorted_recommendations) - 20} more recommendations[/]"
+                    "...",
+                    "...",
+                    "...",
+                    "...",
+                    "...",
+                    "...",
+                    "...",
+                    f"[dim]+{len(sorted_recommendations) - 20} more recommendations[/]",
                 )
-            
+
             console.print(table)
-            
+
             # Financial Summary Panel
             financial_content = f"""
 💰 RI Investment Portfolio Summary:
@@ -869,40 +931,42 @@ class ReservationOptimizer:
 🔄 Cost Transformation:
    • From: {format_cost(results.total_current_on_demand_cost)} On-Demand
    • To: {format_cost(results.total_potential_ri_cost)} Reserved Instance
-   • Savings: {format_cost(results.total_annual_savings)} ({(results.total_annual_savings/results.total_current_on_demand_cost*100):.1f}% reduction)
+   • Savings: {format_cost(results.total_annual_savings)} ({(results.total_annual_savings / results.total_current_on_demand_cost * 100):.1f}% reduction)
             """
-            
-            console.print(create_panel(
-                financial_content.strip(),
-                title="💼 RI Procurement Financial Analysis",
-                border_style="blue"
-            ))
+
+            console.print(
+                create_panel(
+                    financial_content.strip(), title="💼 RI Procurement Financial Analysis", border_style="blue"
+                )
+            )
 
 
 # CLI Integration for enterprise runbooks commands
 @click.command()
-@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
-@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
-@click.option('--services', multiple=True, 
-              type=click.Choice(['ec2', 'rds', 'elasticache', 'redshift']),
-              help='AWS services to analyze for RI opportunities')
-@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
-@click.option('--usage-threshold-days', type=int, default=90, 
-              help='Usage analysis period in days')
+@click.option("--profile", help="AWS profile name (3-tier priority: User > Environment > Default)")
+@click.option("--regions", multiple=True, help="AWS regions to analyze (space-separated)")
+@click.option(
+    "--services",
+    multiple=True,
+    type=click.Choice(["ec2", "rds", "elasticache", "redshift"]),
+    help="AWS services to analyze for RI opportunities",
+)
+@click.option("--dry-run/--no-dry-run", default=True, help="Execute in dry-run mode (READ-ONLY analysis)")
+@click.option("--usage-threshold-days", type=int, default=90, help="Usage analysis period in days")
 def reservation_optimizer(profile, regions, services, dry_run, usage_threshold_days):
     """
     Reserved Instance Optimizer - Enterprise Multi-Service RI Strategy
-    
+
     Comprehensive RI analysis and procurement recommendations:
     • Multi-service RI analysis (EC2, RDS, ElastiCache, Redshift)
     • Historical usage pattern analysis with financial modeling
     • Break-even analysis and ROI calculations for RI procurement
     • Portfolio optimization with risk assessment and budget constraints
-    
+
     Part of $132,720+ annual savings methodology targeting $3.2M-$17M RI optimization.
-    
+
     SAFETY: READ-ONLY analysis only - no actual RI purchases.
-    
+
     Examples:
         runbooks finops reservation --analyze
         runbooks finops reservation --services ec2 rds --regions us-east-1 us-west-2
@@ -913,37 +977,37 @@ def reservation_optimizer(profile, regions, services, dry_run, usage_threshold_d
         service_enums = []
         if services:
             service_map = {
-                'ec2': RIService.EC2,
-                'rds': RIService.RDS,
-                'elasticache': RIService.ELASTICACHE,
-                'redshift': RIService.REDSHIFT
+                "ec2": RIService.EC2,
+                "rds": RIService.RDS,
+                "elasticache": RIService.ELASTICACHE,
+                "redshift": RIService.REDSHIFT,
             }
             service_enums = [service_map[s] for s in services]
-        
+
         # Initialize optimizer
-        optimizer = ReservationOptimizer(
-            profile_name=profile,
-            regions=list(regions) if regions else None
-        )
-        
+        optimizer = ReservationOptimizer(profile_name=profile, regions=list(regions) if regions else None)
+
         # Override analysis period if specified
         if usage_threshold_days != 90:
             optimizer.analysis_period_days = usage_threshold_days
-        
+
         # Execute comprehensive analysis
-        results = asyncio.run(optimizer.analyze_reservation_opportunities(
-            services=service_enums if service_enums else None,
-            dry_run=dry_run
-        ))
-        
+        results = asyncio.run(
+            optimizer.analyze_reservation_opportunities(
+                services=service_enums if service_enums else None, dry_run=dry_run
+            )
+        )
+
         # Display final success message
         if results.total_annual_savings > 0:
             print_success(f"Analysis complete: {format_cost(results.total_annual_savings)} potential annual savings")
-            print_info(f"Required investment: {format_cost(results.total_upfront_investment)} ({results.portfolio_roi:.1f}% ROI)")
+            print_info(
+                f"Required investment: {format_cost(results.total_upfront_investment)} ({results.portfolio_roi:.1f}% ROI)"
+            )
             print_info(f"Services analyzed: {', '.join([s.value.upper() for s in results.analyzed_services])}")
         else:
             print_info("Analysis complete: No cost-effective RI opportunities identified")
-            
+
     except KeyboardInterrupt:
         print_warning("Analysis interrupted by user")
         raise click.Abort()
@@ -952,5 +1016,5 @@ def reservation_optimizer(profile, regions, services, dry_run, usage_threshold_d
         raise click.Abort()
 
 
-if __name__ == '__main__':
-    reservation_optimizer()
+if __name__ == "__main__":
+    reservation_optimizer()