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

runbooks/common/aws_pricing.py

@@ -37,6 +37,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class AWSPricingResult:
     """Result of AWS pricing calculation."""
+
     service_key: str
     region: str
     monthly_cost: float
@@ -48,9 +49,9 @@ class AWSPricingResult:
 class DynamicAWSPricing:
     """
     Enterprise AWS Pricing Service - Universal Compatibility & Real-time Integration
-    
+
     Strategic Features:
-    - Universal AWS region/partition compatibility 
+    - Universal AWS region/partition compatibility
     - Enterprise performance: <1s response time with intelligent caching
     - Real-time AWS Pricing API integration with thread-safe operations
     - Complete profile integration with --profile and --all patterns
@@ -62,7 +63,7 @@ class DynamicAWSPricing:
     def __init__(self, cache_ttl_hours: int = 24, enable_fallback: bool = True, profile: Optional[str] = None):
         """
         Initialize enterprise dynamic pricing engine.
-        
+
         Args:
             cache_ttl_hours: Cache time-to-live in hours
             enable_fallback: Enable fallback to estimated pricing
@@ -74,28 +75,28 @@ class DynamicAWSPricing:
         self._pricing_cache = {}
         self._cache_lock = threading.RLock()
         self._executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="pricing")
-        
+
         # Regional pricing cache - populated dynamically from AWS Pricing API
         # NO hardcoded multipliers - all pricing retrieved in real-time
         self._regional_pricing_cache = {}
         self._region_cache_lock = threading.RLock()
-        
+
         console.print("[dim]Enterprise AWS Pricing Engine initialized with universal compatibility[/]")
         logger.info(f"Dynamic AWS Pricing Engine initialized with profile: {profile or 'default'}")
 
     def get_ec2_instance_pricing(self, instance_type: str, region: str = "us-east-1") -> AWSPricingResult:
         """
         Get dynamic pricing for EC2 instance type.
-        
+
         Args:
             instance_type: EC2 instance type (e.g., t3.micro)
             region: AWS region for pricing lookup
-            
+
         Returns:
             AWSPricingResult with current EC2 pricing information
         """
         cache_key = f"ec2_instance:{instance_type}:{region}"
-        
+
         with self._cache_lock:
             # Check cache first
             if cache_key in self._pricing_cache:
@@ -106,20 +107,20 @@ class DynamicAWSPricing:
                 else:
                     # Cache expired, remove it
                     del self._pricing_cache[cache_key]
-        
+
         # Try to get real pricing from AWS API
         try:
             pricing_result = self._get_ec2_api_pricing(instance_type, region)
-            
+
             # Cache the result
             with self._cache_lock:
                 self._pricing_cache[cache_key] = pricing_result
-                
+
             return pricing_result
-            
+
         except Exception as e:
             logger.error(f"Failed to get AWS API pricing for {instance_type}: {e}")
-            
+
             if self.enable_fallback:
                 return self._get_ec2_fallback_pricing(instance_type, region)
             else:
@@ -131,40 +132,40 @@ class DynamicAWSPricing:
     def _get_ec2_api_pricing(self, instance_type: str, region: str) -> AWSPricingResult:
         """
         Get EC2 instance pricing from AWS Pricing API.
-        
+
         Args:
             instance_type: EC2 instance type
             region: AWS region
-            
+
         Returns:
             AWSPricingResult with real AWS pricing
         """
         import json
-        
+
         try:
             # AWS Pricing API is only available in us-east-1 region
             # Use enhanced session management for universal AWS environment support
             if self.profile:
                 # Use profile-aware session creation with proper credential resolution
-                session = create_cost_session(self.profile)
-                pricing_client = session.client('pricing', region_name='us-east-1')
+                session = create_cost_session(profile_name=self.profile)
+                pricing_client = session.client("pricing", region_name="us-east-1")
                 logger.debug(f"Created EC2 pricing client with profile: {self.profile}")
             else:
                 # Try environment-based credentials with fallback chain
                 try:
                     # First attempt: Use default credential chain
-                    pricing_client = boto3.client('pricing', region_name='us-east-1')
+                    pricing_client = boto3.client("pricing", region_name="us-east-1")
                     logger.debug("Created EC2 pricing client with default credentials")
                 except NoCredentialsError:
                     # Second attempt: Try with AWS_PROFILE if set
-                    aws_profile = os.getenv('AWS_PROFILE')
+                    aws_profile = os.getenv("AWS_PROFILE")
                     if aws_profile:
                         session = boto3.Session(profile_name=aws_profile)
-                        pricing_client = session.client('pricing', region_name='us-east-1')
+                        pricing_client = session.client("pricing", region_name="us-east-1")
                         logger.debug(f"Created EC2 pricing client with AWS_PROFILE: {aws_profile}")
                     else:
                         raise NoCredentialsError("No AWS credentials available for Pricing API")
-            
+
             # Query AWS Pricing API for EC2 instances - get multiple results to find on-demand pricing
             response = pricing_client.get_products(
                 ServiceCode="AmazonEC2",
@@ -175,35 +176,35 @@ class DynamicAWSPricing:
                     {"Type": "TERM_MATCH", "Field": "tenancy", "Value": "Shared"},
                     {"Type": "TERM_MATCH", "Field": "operatingSystem", "Value": "Linux"},
                     {"Type": "TERM_MATCH", "Field": "preInstalledSw", "Value": "NA"},
-                    {"Type": "TERM_MATCH", "Field": "licenseModel", "Value": "No License required"}
+                    {"Type": "TERM_MATCH", "Field": "licenseModel", "Value": "No License required"},
                 ],
-                MaxResults=10  # Get more results to find on-demand pricing
+                MaxResults=10,  # Get more results to find on-demand pricing
             )
-            
-            if not response.get('PriceList'):
+
+            if not response.get("PriceList"):
                 raise ValueError(f"No pricing data found for {instance_type} in {region}")
-            
+
             # Extract pricing from response - prioritize on-demand over reservation pricing
             hourly_rate = None
 
-            for price_item in response['PriceList']:
+            for price_item in response["PriceList"]:
                 try:
                     price_data = json.loads(price_item)
-                    product = price_data.get('product', {})
-                    attributes = product.get('attributes', {})
+                    product = price_data.get("product", {})
+                    attributes = product.get("attributes", {})
 
                     # Skip reservation instances, focus on on-demand
-                    usage_type = attributes.get('usagetype', '')
-                    market_option = attributes.get('marketoption', '')
+                    usage_type = attributes.get("usagetype", "")
+                    market_option = attributes.get("marketoption", "")
 
                     # Skip if this is reservation pricing
-                    if 'reservation' in usage_type.lower() or 'reserved' in market_option.lower():
+                    if "reservation" in usage_type.lower() or "reserved" in market_option.lower():
                         logger.debug(f"Skipping reservation pricing for {instance_type}")
                         continue
 
                     # Navigate the pricing structure
-                    terms = price_data.get('terms', {})
-                    on_demand = terms.get('OnDemand', {})
+                    terms = price_data.get("terms", {})
+                    on_demand = terms.get("OnDemand", {})
 
                     if not on_demand:
                         continue
@@ -212,7 +213,7 @@ class DynamicAWSPricing:
                     term_key = list(on_demand.keys())[0]
                     term_data = on_demand[term_key]
 
-                    price_dimensions = term_data.get('priceDimensions', {})
+                    price_dimensions = term_data.get("priceDimensions", {})
                     if not price_dimensions:
                         continue
 
@@ -220,10 +221,10 @@ class DynamicAWSPricing:
                     price_dim_key = list(price_dimensions.keys())[0]
                     price_dim = price_dimensions[price_dim_key]
 
-                    price_per_unit = price_dim.get('pricePerUnit', {})
-                    usd_price = price_per_unit.get('USD')
+                    price_per_unit = price_dim.get("pricePerUnit", {})
+                    usd_price = price_per_unit.get("USD")
 
-                    if usd_price and usd_price != '0.0000000000':
+                    if usd_price and usd_price != "0.0000000000":
                         hourly_rate = float(usd_price)
                         logger.info(f"Found AWS API on-demand pricing for {instance_type}: ${hourly_rate}/hour")
                         # Log the pricing source for debugging
@@ -233,24 +234,24 @@ class DynamicAWSPricing:
                 except (KeyError, ValueError, IndexError, json.JSONDecodeError) as parse_error:
                     logger.debug(f"Failed to parse EC2 pricing data: {parse_error}")
                     continue
-            
+
             if hourly_rate is None:
                 raise ValueError(f"Could not extract valid pricing for {instance_type}")
-                
+
             # Convert hourly to monthly (24 hours * 30 days)
             monthly_cost = hourly_rate * 24 * 30
-            
+
             logger.info(f"AWS API pricing for {instance_type} in {region}: ${monthly_cost:.4f}/month")
-            
+
             return AWSPricingResult(
                 service_key=f"ec2_instance:{instance_type}",
                 region=region,
                 monthly_cost=monthly_cost,
                 pricing_source="aws_api",
                 last_updated=datetime.now(),
-                currency="USD"
+                currency="USD",
             )
-            
+
         except (ClientError, NoCredentialsError) as e:
             logger.warning(f"AWS Pricing API unavailable for {instance_type}: {e}")
             raise e
@@ -261,118 +262,122 @@ class DynamicAWSPricing:
     # ============================================================================
     # ENTERPRISE SERVICE PRICING METHODS - Strategic Requirements Implementation
     # ============================================================================
-    
+
     def get_ec2_instance_hourly_cost(self, instance_type: str, region: str = "us-east-1") -> float:
         """
         Get EC2 instance hourly cost (Strategic Requirement #1).
-        
+
         Args:
             instance_type: EC2 instance type (e.g., t3.micro)
             region: AWS region for pricing lookup
-            
+
         Returns:
             Hourly cost in USD
         """
         result = self.get_ec2_instance_pricing(instance_type, region)
         return result.monthly_cost / (24 * 30)  # Convert monthly to hourly
-    
+
     def get_eip_monthly_cost(self, region: str = "us-east-1") -> float:
         """
         Get Elastic IP monthly cost (Strategic Requirement #2).
-        
+
         Args:
             region: AWS region for pricing lookup
-            
+
         Returns:
             Monthly cost in USD for unassociated EIP
         """
         result = self.get_service_pricing("elastic_ip", region)
         return result.monthly_cost
-    
+
     def get_nat_gateway_monthly_cost(self, region: str = "us-east-1") -> float:
         """
         Get NAT Gateway monthly cost (Strategic Requirement #3).
-        
+
         Args:
             region: AWS region for pricing lookup
-            
+
         Returns:
             Monthly cost in USD for NAT Gateway
         """
         result = self.get_service_pricing("nat_gateway", region)
         return result.monthly_cost
-    
+
     def get_ebs_gb_monthly_cost(self, volume_type: str = "gp3", region: str = "us-east-1") -> float:
         """
         Get EBS per-GB monthly cost (Strategic Requirement #4).
-        
+
         Args:
             volume_type: EBS volume type (gp3, gp2, io1, io2, st1, sc1)
             region: AWS region for pricing lookup
-            
+
         Returns:
             Monthly cost per GB in USD
         """
         result = self.get_service_pricing(f"ebs_{volume_type}", region)
         return result.monthly_cost
-    
+
     # Additional Enterprise Service Methods
     def get_vpc_endpoint_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get VPC Endpoint monthly cost."""
         result = self.get_service_pricing("vpc_endpoint", region)
         return result.monthly_cost
-    
+
     def get_transit_gateway_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get Transit Gateway monthly cost."""
         result = self.get_service_pricing("transit_gateway", region)
         return result.monthly_cost
-    
+
     def get_load_balancer_monthly_cost(self, lb_type: str = "application", region: str = "us-east-1") -> float:
         """
         Get Load Balancer monthly cost.
-        
+
         Args:
             lb_type: Load balancer type (application, network, gateway)
             region: AWS region
-            
+
         Returns:
             Monthly cost in USD
         """
         result = self.get_service_pricing(f"loadbalancer_{lb_type}", region)
         return result.monthly_cost
-    
-    def get_rds_instance_monthly_cost(self, instance_class: str, engine: str = "mysql", region: str = "us-east-1") -> float:
+
+    def get_rds_instance_monthly_cost(
+        self, instance_class: str, engine: str = "mysql", region: str = "us-east-1"
+    ) -> float:
         """
         Get RDS instance monthly cost.
-        
+
         Args:
             instance_class: RDS instance class (e.g., db.t3.micro)
             engine: Database engine (mysql, postgres, oracle, etc.)
             region: AWS region
-            
+
         Returns:
             Monthly cost in USD
         """
         result = self.get_service_pricing(f"rds_{engine}_{instance_class}", region)
         return result.monthly_cost
-    
+
     # ============================================================================
     # ENTERPRISE PERFORMANCE METHODS - <1s Response Time Requirements
     # ============================================================================
-    
-    def get_multi_service_pricing(self, service_requests: List[Tuple[str, str]], max_workers: int = 4) -> Dict[str, AWSPricingResult]:
+
+    def get_multi_service_pricing(
+        self, service_requests: List[Tuple[str, str]], max_workers: int = 4
+    ) -> Dict[str, AWSPricingResult]:
         """
         Get pricing for multiple services concurrently for enterprise performance.
-        
+
         Args:
             service_requests: List of (service_key, region) tuples
             max_workers: Maximum concurrent workers
-            
+
         Returns:
             Dictionary mapping service_key:region to AWSPricingResult
         """
         results = {}
-        
+
         def fetch_pricing(service_request):
             service_key, region = service_request
             try:
@@ -380,13 +385,11 @@ class DynamicAWSPricing:
             except Exception as e:
                 logger.error(f"Failed to fetch pricing for {service_key} in {region}: {e}")
                 return f"{service_key}:{region}", None
-        
+
         # Use existing executor for thread management
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_service = {
-                executor.submit(fetch_pricing, req): req for req in service_requests
-            }
-            
+            future_to_service = {executor.submit(fetch_pricing, req): req for req in service_requests}
+
             for future in as_completed(future_to_service):
                 service_request = future_to_service[future]
                 try:
@@ -396,30 +399,35 @@ class DynamicAWSPricing:
                 except Exception as e:
                     service_key, region = service_request
                     logger.error(f"Concurrent pricing fetch failed for {service_key}:{region}: {e}")
-        
+
         return results
-    
+
     def warm_cache_for_region(self, region: str, services: Optional[List[str]] = None) -> None:
         """
         Pre-warm pricing cache for a region to ensure <1s response times.
-        
+
         Args:
             region: AWS region to warm cache for
             services: List of services to warm (default: common services)
         """
         if services is None:
             services = [
-                "ec2_instance", "elastic_ip", "nat_gateway", "ebs_gp3", 
-                "vpc_endpoint", "transit_gateway", "loadbalancer_application"
+                "ec2_instance",
+                "elastic_ip",
+                "nat_gateway",
+                "ebs_gp3",
+                "vpc_endpoint",
+                "transit_gateway",
+                "loadbalancer_application",
             ]
-        
+
         service_requests = [(service, region) for service in services]
-        
+
         console.print(f"[dim]Warming pricing cache for {region} with {len(services)} services...[/]")
         start_time = time.time()
-        
+
         self.get_multi_service_pricing(service_requests)
-        
+
         elapsed = time.time() - start_time
         console.print(f"[dim]Cache warming completed in {elapsed:.2f}s[/]")
         logger.info(f"Pricing cache warmed for {region} in {elapsed:.2f}s")
@@ -427,141 +435,141 @@ class DynamicAWSPricing:
     def _get_ec2_fallback_pricing(self, instance_type: str, region: str) -> AWSPricingResult:
         """
         ENTERPRISE CRITICAL: EC2 fallback pricing for absolute last resort.
-        
+
         Args:
             instance_type: EC2 instance type
             region: AWS region
-            
+
         Returns:
             AWSPricingResult with estimated pricing
         """
         console.print(f"[red]⚠ ENTERPRISE WARNING: Using fallback pricing for EC2 {instance_type}[/red]")
-        
+
         # Calculate base hourly rate from AWS documentation patterns
         hourly_rate = self._calculate_ec2_from_aws_patterns(instance_type)
-        
+
         if hourly_rate <= 0:
             raise RuntimeError(
                 f"ENTERPRISE VIOLATION: No dynamic pricing available for {instance_type} "
                 f"in region {region}. Cannot proceed without hardcoded values."
             )
-        
+
         # Apply dynamic regional multiplier from AWS Pricing API
         region_multiplier = self.get_regional_pricing_multiplier("ec2_instance", region, "us-east-1")
         adjusted_hourly_rate = hourly_rate * region_multiplier
         monthly_cost = adjusted_hourly_rate * 24 * 30
-        
+
         logger.warning(f"Using calculated EC2 fallback for {instance_type} in {region}: ${monthly_cost:.4f}/month")
-        
+
         return AWSPricingResult(
             service_key=f"ec2_instance:{instance_type}",
             region=region,
             monthly_cost=monthly_cost,
             pricing_source="calculated_fallback",
             last_updated=datetime.now(),
-            currency="USD"
+            currency="USD",
         )
 
     def _calculate_ec2_from_aws_patterns(self, instance_type: str) -> float:
         """
         Calculate EC2 pricing using AWS documented patterns and ratios.
-        
+
         Based on AWS instance family patterns, not hardcoded business values.
-        
+
         Returns:
             Hourly rate or 0 if cannot be calculated
         """
         instance_type = instance_type.lower()
-        
+
         # Parse instance type (e.g., "t3.micro" -> family="t3", size="micro")
         try:
-            family, size = instance_type.split('.', 1)
+            family, size = instance_type.split(".", 1)
         except ValueError:
             logger.error(f"Invalid instance type format: {instance_type}")
             return 0.0
-        
+
         # Instance family base rates from AWS pricing patterns
         # These represent documented relative pricing, not hardcoded business values
         family_base_factors = {
-            't3': 1.0,     # Burstable performance baseline
-            't2': 1.12,    # Previous generation, slightly higher
-            'm5': 1.85,    # General purpose, balanced
-            'c5': 1.63,    # Compute optimized
-            'r5': 2.42,    # Memory optimized
-            'm4': 1.75,    # Previous generation general purpose
-            'c4': 1.54,    # Previous generation compute
-            'r4': 2.28,    # Previous generation memory
+            "t3": 1.0,  # Burstable performance baseline
+            "t2": 1.12,  # Previous generation, slightly higher
+            "m5": 1.85,  # General purpose, balanced
+            "c5": 1.63,  # Compute optimized
+            "r5": 2.42,  # Memory optimized
+            "m4": 1.75,  # Previous generation general purpose
+            "c4": 1.54,  # Previous generation compute
+            "r4": 2.28,  # Previous generation memory
         }
-        
+
         # Size multipliers based on AWS documented scaling
         size_multipliers = {
-            'nano': 0.25,   # Quarter of micro
-            'micro': 1.0,   # Base unit
-            'small': 2.0,   # Double micro
-            'medium': 4.0,  # Double small
-            'large': 8.0,   # Double medium
-            'xlarge': 16.0, # Double large
-            '2xlarge': 32.0, # Double xlarge
-            '4xlarge': 64.0, # Double 2xlarge
+            "nano": 0.25,  # Quarter of micro
+            "micro": 1.0,  # Base unit
+            "small": 2.0,  # Double micro
+            "medium": 4.0,  # Double small
+            "large": 8.0,  # Double medium
+            "xlarge": 16.0,  # Double large
+            "2xlarge": 32.0,  # Double xlarge
+            "4xlarge": 64.0,  # Double 2xlarge
         }
-        
+
         family_factor = family_base_factors.get(family, 0.0)
         size_multiplier = size_multipliers.get(size, 0.0)
-        
+
         if family_factor == 0.0:
             logger.warning(f"Unknown EC2 family: {family}")
             return 0.0
-            
+
         if size_multiplier == 0.0:
             logger.warning(f"Unknown EC2 size: {size}")
             return 0.0
-        
+
         # Calculate using AWS documented scaling patterns
         # Instead of hardcoded baseline, use the family and size factors
         # This calculates relative pricing without hardcoded base rates
-        
+
         # Use the smallest family factor as baseline to avoid hardcoded values
         baseline_factor = min(family_base_factors.values())  # t3 = 1.0
-        
+
         # Try to get real baseline pricing from AWS API for any known instance type
         baseline_rate = None
-        known_instance_types = ['t3.micro', 't2.micro', 'm5.large']
-        
+        known_instance_types = ["t3.micro", "t2.micro", "m5.large"]
+
         for baseline_instance in known_instance_types:
             try:
                 pricing_engine = get_aws_pricing_engine(enable_fallback=False, profile=self.profile)
-                real_pricing = pricing_engine._get_ec2_api_pricing(baseline_instance, 'us-east-1')
+                real_pricing = pricing_engine._get_ec2_api_pricing(baseline_instance, "us-east-1")
                 baseline_rate = real_pricing.monthly_cost / (24 * 30)  # Convert to hourly
                 logger.info(f"Using {baseline_instance} as baseline: ${baseline_rate}/hour")
                 break
             except Exception as e:
                 logger.debug(f"Could not get pricing for {baseline_instance}: {e}")
                 continue
-        
+
         if baseline_rate is None:
             # If we can't get any real pricing, we cannot calculate reliably
             logger.error(f"ENTERPRISE COMPLIANCE: Cannot calculate {instance_type} without AWS API baseline")
             return 0.0
-            
+
         # Calculate relative pricing based on AWS documented ratios and real baseline
         calculated_rate = baseline_rate * family_factor * size_multiplier
-        
+
         logger.info(f"Calculated {instance_type} rate: ${calculated_rate}/hour using AWS patterns")
         return calculated_rate
 
     def get_service_pricing(self, service_key: str, region: str = "us-east-1") -> AWSPricingResult:
         """
         Get dynamic pricing for AWS service.
-        
+
         Args:
             service_key: Service identifier (vpc, nat_gateway, elastic_ip, etc.)
             region: AWS region for pricing lookup
-            
+
         Returns:
             AWSPricingResult with current pricing information
         """
         cache_key = f"{service_key}:{region}"
-        
+
         with self._cache_lock:
             # Check cache first
             if cache_key in self._pricing_cache:
@@ -572,20 +580,20 @@ class DynamicAWSPricing:
                 else:
                     # Cache expired, remove it
                     del self._pricing_cache[cache_key]
-        
+
         # Try to get real pricing from AWS API
         try:
             pricing_result = self._get_aws_api_pricing(service_key, region)
-            
+
             # Cache the result
             with self._cache_lock:
                 self._pricing_cache[cache_key] = pricing_result
-                
+
             return pricing_result
-            
+
         except Exception as e:
             logger.error(f"Failed to get AWS API pricing for {service_key}: {e}")
-            
+
             if self.enable_fallback:
                 return self._get_fallback_pricing(service_key, region)
             else:
@@ -612,21 +620,21 @@ class DynamicAWSPricing:
             # Use enhanced session management for universal AWS environment support
             if self.profile:
                 # Use profile-aware session creation with proper credential resolution
-                session = create_cost_session(self.profile)
-                pricing_client = session.client('pricing', region_name='us-east-1')
+                session = create_cost_session(profile_name=self.profile)
+                pricing_client = session.client("pricing", region_name="us-east-1")
                 logger.debug(f"Created pricing client with profile: {self.profile}")
             else:
                 # Try environment-based credentials with fallback chain
                 try:
                     # First attempt: Use default credential chain
-                    pricing_client = boto3.client('pricing', region_name='us-east-1')
+                    pricing_client = boto3.client("pricing", region_name="us-east-1")
                     logger.debug("Created pricing client with default credentials")
                 except NoCredentialsError:
                     # Second attempt: Try with AWS_PROFILE if set
-                    aws_profile = os.getenv('AWS_PROFILE')
+                    aws_profile = os.getenv("AWS_PROFILE")
                     if aws_profile:
                         session = boto3.Session(profile_name=aws_profile)
-                        pricing_client = session.client('pricing', region_name='us-east-1')
+                        pricing_client = session.client("pricing", region_name="us-east-1")
                         logger.debug(f"Created pricing client with AWS_PROFILE: {aws_profile}")
                     else:
                         # Enhanced credential guidance
@@ -636,7 +644,7 @@ class DynamicAWSPricing:
                         console.print("   2. AWS SSO: [cyan]aws sso login --profile your-profile[/]")
                         console.print("   3. Environment: [cyan]export AWS_ACCESS_KEY_ID=...[/]")
                         raise NoCredentialsError("No AWS credentials available for Pricing API")
-            
+
             # Enterprise Service Mapping for AWS Pricing API - Complete Coverage
             service_mapping = {
                 # Core Networking Services - NAT Gateway (fallback to broad search)
@@ -645,33 +653,32 @@ class DynamicAWSPricing:
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                    ]  # Simplified - will search for NAT Gateway in response
+                    ],  # Simplified - will search for NAT Gateway in response
                 },
                 "elastic_ip": {
-                    "service_code": "AmazonEC2", 
+                    "service_code": "AmazonEC2",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "IP Address"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "IP Address"},
+                    ],
                 },
                 "vpc_endpoint": {
                     "service_code": "AmazonVPC",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "VpcEndpoint"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "VpcEndpoint"},
+                    ],
                 },
                 "transit_gateway": {
                     "service_code": "AmazonVPC",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Transit Gateway"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Transit Gateway"},
+                    ],
                 },
-                
                 # Compute Services
                 "ec2_instance": {
                     "service_code": "AmazonEC2",
@@ -680,10 +687,9 @@ class DynamicAWSPricing:
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                         {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Compute Instance"},
                         {"Type": "TERM_MATCH", "Field": "tenancy", "Value": "Shared"},
-                        {"Type": "TERM_MATCH", "Field": "operatingSystem", "Value": "Linux"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "operatingSystem", "Value": "Linux"},
+                    ],
                 },
-                
                 # Storage Services
                 "ebs_gp3": {
                     "service_code": "AmazonEC2",
@@ -692,8 +698,8 @@ class DynamicAWSPricing:
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                         {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"},
                         {"Type": "TERM_MATCH", "Field": "volumeType", "Value": "General Purpose"},
-                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "gp3"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "gp3"},
+                    ],
                 },
                 "ebs_gp2": {
                     "service_code": "AmazonEC2",
@@ -702,8 +708,8 @@ class DynamicAWSPricing:
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                         {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"},
                         {"Type": "TERM_MATCH", "Field": "volumeType", "Value": "General Purpose"},
-                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "gp2"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "gp2"},
+                    ],
                 },
                 "ebs_io1": {
                     "service_code": "AmazonEC2",
@@ -712,8 +718,8 @@ class DynamicAWSPricing:
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                         {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"},
                         {"Type": "TERM_MATCH", "Field": "volumeType", "Value": "Provisioned IOPS"},
-                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "io1"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "io1"},
+                    ],
                 },
                 "ebs_io2": {
                     "service_code": "AmazonEC2",
@@ -722,44 +728,43 @@ class DynamicAWSPricing:
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                         {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"},
                         {"Type": "TERM_MATCH", "Field": "volumeType", "Value": "Provisioned IOPS"},
-                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "io2"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "io2"},
+                    ],
                 },
-                
                 # Load Balancer Services
                 "loadbalancer_application": {
                     "service_code": "AWSELB",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Application"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Application"},
+                    ],
                 },
                 "loadbalancer_network": {
                     "service_code": "AWSELB",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Network"}
-                    ]
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Network"},
+                    ],
                 },
                 "loadbalancer_gateway": {
                     "service_code": "AWSELB",
                     "location": self._get_aws_location_name(region),
                     "filters": [
                         {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
-                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Gateway"}
-                    ]
-                }
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Load Balancer-Gateway"},
+                    ],
+                },
             }
-            
+
             # Handle dynamic RDS service keys (rds_engine_instanceclass)
             if service_key.startswith("rds_"):
                 parts = service_key.split("_")
                 if len(parts) >= 3:
                     engine = parts[1]
                     instance_class = "_".join(parts[2:])
-                    
+
                     service_mapping[service_key] = {
                         "service_code": "AmazonRDS",
                         "location": self._get_aws_location_name(region),
@@ -767,10 +772,10 @@ class DynamicAWSPricing:
                             {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_aws_location_name(region)},
                             {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Database Instance"},
                             {"Type": "TERM_MATCH", "Field": "databaseEngine", "Value": engine.title()},
-                            {"Type": "TERM_MATCH", "Field": "instanceType", "Value": instance_class}
-                        ]
+                            {"Type": "TERM_MATCH", "Field": "instanceType", "Value": instance_class},
+                        ],
                     }
-            
+
             # Handle data_transfer service with graceful fallback
             if service_key == "data_transfer":
                 print_warning("data_transfer service not supported by AWS Pricing API - using standard rates")
@@ -780,43 +785,43 @@ class DynamicAWSPricing:
                     region=region,
                     monthly_cost=0.045,  # $0.045/GB for NAT Gateway data processing
                     pricing_source="aws_standard_rates",
-                    last_updated=datetime.now()
+                    last_updated=datetime.now(),
                 )
 
             if service_key not in service_mapping:
                 raise ValueError(f"Service {service_key} not supported by AWS Pricing API integration")
-            
+
             service_info = service_mapping[service_key]
-            
+
             # Query AWS Pricing API
             response = pricing_client.get_products(
                 ServiceCode=service_info["service_code"],
                 Filters=service_info["filters"],
-                MaxResults=5  # Get more results to find best match
+                MaxResults=5,  # Get more results to find best match
             )
-            
-            if not response.get('PriceList'):
+
+            if not response.get("PriceList"):
                 raise ValueError(f"No pricing data found for {service_key} in {region}")
-            
+
             # Extract pricing from response with service-specific filtering
             hourly_rate = None
 
-            for price_item in response['PriceList']:
+            for price_item in response["PriceList"]:
                 try:
                     price_data = json.loads(price_item)
-                    product = price_data.get('product', {})
-                    attributes = product.get('attributes', {})
+                    product = price_data.get("product", {})
+                    attributes = product.get("attributes", {})
 
                     # Service-specific filtering for broad searches
                     if service_key == "nat_gateway":
                         # Look for NAT Gateway specific attributes
                         item_text = json.dumps(attributes).lower()
-                        if not any(keyword in item_text for keyword in ['nat', 'natgateway', 'nat-gateway']):
+                        if not any(keyword in item_text for keyword in ["nat", "natgateway", "nat-gateway"]):
                             continue  # Skip items that don't contain NAT references
 
                     # Navigate the pricing structure
-                    terms = price_data.get('terms', {})
-                    on_demand = terms.get('OnDemand', {})
+                    terms = price_data.get("terms", {})
+                    on_demand = terms.get("OnDemand", {})
 
                     if not on_demand:
                         continue
@@ -825,7 +830,7 @@ class DynamicAWSPricing:
                     term_key = list(on_demand.keys())[0]
                     term_data = on_demand[term_key]
 
-                    price_dimensions = term_data.get('priceDimensions', {})
+                    price_dimensions = term_data.get("priceDimensions", {})
                     if not price_dimensions:
                         continue
 
@@ -833,15 +838,17 @@ class DynamicAWSPricing:
                     price_dim_key = list(price_dimensions.keys())[0]
                     price_dim = price_dimensions[price_dim_key]
 
-                    price_per_unit = price_dim.get('pricePerUnit', {})
-                    usd_price = price_per_unit.get('USD')
+                    price_per_unit = price_dim.get("pricePerUnit", {})
+                    usd_price = price_per_unit.get("USD")
 
-                    if usd_price and usd_price != '0.0000000000':
+                    if usd_price and usd_price != "0.0000000000":
                         hourly_rate = float(usd_price)
                         monthly_cost = hourly_rate * 24 * 30
 
                         # Honest success reporting
-                        console.print(f"[green]✅ Real-time AWS API pricing[/]: {service_key} = ${monthly_cost:.2f}/month")
+                        console.print(
+                            f"[green]✅ Real-time AWS API pricing[/]: {service_key} = ${monthly_cost:.2f}/month"
+                        )
                         logger.info(f"Found AWS API pricing for {service_key}: ${hourly_rate}/hour")
 
                         # Log what we found for debugging
@@ -852,24 +859,24 @@ class DynamicAWSPricing:
                 except (KeyError, ValueError, IndexError, json.JSONDecodeError) as parse_error:
                     logger.debug(f"Failed to parse pricing data: {parse_error}")
                     continue
-            
+
             if hourly_rate is None:
                 raise ValueError(f"Could not extract valid pricing for {service_key}")
-                
+
             # Convert hourly to monthly (24 hours * 30 days)
             monthly_cost = hourly_rate * 24 * 30
-            
+
             logger.info(f"AWS API pricing for {service_key} in {region}: ${monthly_cost:.4f}/month")
-            
+
             return AWSPricingResult(
                 service_key=service_key,
                 region=region,
                 monthly_cost=monthly_cost,
                 pricing_source="aws_api",
                 last_updated=datetime.now(),
-                currency="USD"
+                currency="USD",
             )
-            
+
         except (ClientError, NoCredentialsError) as e:
             logger.warning(f"AWS Pricing API unavailable for {service_key}: {e}")
             raise e
@@ -906,9 +913,9 @@ class DynamicAWSPricing:
                 monthly_cost=override_cost,
                 pricing_source="environment_override",
                 last_updated=datetime.now(),
-                currency="USD"
+                currency="USD",
             )
-        
+
         # Try alternative approach: Query public AWS docs or use Cloud Formation cost estimation
         try:
             estimated_cost = self._query_alternative_pricing_sources(service_key, region)
@@ -919,22 +926,22 @@ class DynamicAWSPricing:
                     monthly_cost=estimated_cost,
                     pricing_source="alternative_source",
                     last_updated=datetime.now(),
-                    currency="USD"
+                    currency="USD",
                 )
         except Exception as e:
             logger.debug(f"Alternative pricing source failed: {e}")
-        
+
         # LAST RESORT: Calculated estimates from AWS documentation
         # These are NOT hardcoded business values but technical calculations
         # Based on AWS official documentation and calculator methodology
         base_hourly_rates_from_aws_docs = self._calculate_from_aws_documentation(service_key)
-        
+
         if not base_hourly_rates_from_aws_docs:
             raise RuntimeError(
                 f"ENTERPRISE VIOLATION: No dynamic pricing available for {service_key} "
                 f"in region {region}. Cannot proceed without hardcoded values."
             )
-        
+
         # Apply dynamic regional multiplier from AWS Pricing API
         region_multiplier = self.get_regional_pricing_multiplier(service_key, region, "us-east-1")
         hourly_rate = base_hourly_rates_from_aws_docs * region_multiplier
@@ -951,7 +958,7 @@ class DynamicAWSPricing:
             monthly_cost=monthly_cost,
             pricing_source="standard_aws_rate",
             last_updated=datetime.now(),
-            currency="USD"
+            currency="USD",
         )
 
     def _check_pricing_overrides(self, service_key: str, region: str) -> float:
@@ -1004,12 +1011,9 @@ class DynamicAWSPricing:
         # PRIORITY 1: Check for historical cached data from other regions
         with self._cache_lock:
             for cache_key, cached_result in self._pricing_cache.items():
-                if (cached_result.service_key == service_key and
-                    cached_result.pricing_source == "aws_api"):
+                if cached_result.service_key == service_key and cached_result.pricing_source == "aws_api":
                     # Found historical AWS API data, apply regional multiplier
-                    multiplier = self.get_regional_pricing_multiplier(
-                        service_key, region, cached_result.region
-                    )
+                    multiplier = self.get_regional_pricing_multiplier(service_key, region, cached_result.region)
                     estimated_cost = cached_result.monthly_cost * multiplier
                     logger.info(f"Using historical pricing data for {service_key}: ${estimated_cost}/month")
                     console.print(f"[blue]ℹ Using historical AWS API data with regional adjustment[/]")
@@ -1022,7 +1026,9 @@ class DynamicAWSPricing:
                 us_east_pricing = self._get_aws_api_pricing(service_key, "us-east-1")
                 multiplier = self.get_regional_pricing_multiplier(service_key, region, "us-east-1")
                 estimated_cost = us_east_pricing.monthly_cost * multiplier
-                logger.info(f"Using us-east-1 pricing with regional multiplier for {service_key}: ${estimated_cost}/month")
+                logger.info(
+                    f"Using us-east-1 pricing with regional multiplier for {service_key}: ${estimated_cost}/month"
+                )
                 console.print(f"[blue]ℹ Using us-east-1 pricing with {multiplier:.3f}x regional adjustment[/]")
                 return estimated_cost
             except Exception as e:
@@ -1053,10 +1059,10 @@ class DynamicAWSPricing:
         # Standard AWS rates from pricing documentation (us-east-1)
         # These are NOT hardcoded business values but technical reference rates
         aws_documented_hourly_rates = {
-            "nat_gateway": 0.045,      # AWS standard NAT Gateway rate
-            "elastic_ip": 0.005,       # AWS standard idle EIP rate
-            "vpc_endpoint": 0.01,      # AWS standard interface endpoint rate
-            "transit_gateway": 0.05,   # AWS standard Transit Gateway rate
+            "nat_gateway": 0.045,  # AWS standard NAT Gateway rate
+            "elastic_ip": 0.005,  # AWS standard idle EIP rate
+            "vpc_endpoint": 0.01,  # AWS standard interface endpoint rate
+            "transit_gateway": 0.05,  # AWS standard Transit Gateway rate
             "ebs_gp3": 0.08 / (24 * 30),  # AWS standard GP3 per GB/month to hourly
             "ebs_gp2": 0.10 / (24 * 30),  # AWS standard GP2 per GB/month to hourly
         }
@@ -1075,10 +1081,10 @@ class DynamicAWSPricing:
     def _get_aws_location_name(self, region: str) -> str:
         """
         Convert AWS region code to location name used by Pricing API.
-        
+
         Args:
             region: AWS region code
-            
+
         Returns:
             AWS location name for Pricing API
         """
@@ -1089,7 +1095,6 @@ class DynamicAWSPricing:
             "us-east-2": "US East (Ohio)",
             "us-west-1": "US West (N. California)",
             "us-west-2": "US West (Oregon)",
-            
             # EU Regions
             "eu-central-1": "Europe (Frankfurt)",
             "eu-central-2": "Europe (Zurich)",
@@ -1099,7 +1104,6 @@ class DynamicAWSPricing:
             "eu-south-1": "Europe (Milan)",
             "eu-south-2": "Europe (Spain)",
             "eu-north-1": "Europe (Stockholm)",
-            
             # Asia Pacific Regions
             "ap-northeast-1": "Asia Pacific (Tokyo)",
             "ap-northeast-2": "Asia Pacific (Seoul)",
@@ -1111,7 +1115,6 @@ class DynamicAWSPricing:
             "ap-south-1": "Asia Pacific (Mumbai)",
             "ap-south-2": "Asia Pacific (Hyderabad)",
             "ap-east-1": "Asia Pacific (Hong Kong)",
-            
             # Other Regions
             "ca-central-1": "Canada (Central)",
             "ca-west-1": "Canada (West)",
@@ -1119,69 +1122,69 @@ class DynamicAWSPricing:
             "af-south-1": "Africa (Cape Town)",
             "me-south-1": "Middle East (Bahrain)",
             "me-central-1": "Middle East (UAE)",
-            
             # GovCloud
             "us-gov-east-1": "AWS GovCloud (US-East)",
             "us-gov-west-1": "AWS GovCloud (US-West)",
-            
             # China (Note: Pricing API may not be available)
             "cn-north-1": "China (Beijing)",
             "cn-northwest-1": "China (Ningxia)",
         }
-        
+
         return location_mapping.get(region, "US East (N. Virginia)")
 
-    def get_regional_pricing_multiplier(self, service_key: str, target_region: str, base_region: str = "us-east-1") -> float:
+    def get_regional_pricing_multiplier(
+        self, service_key: str, target_region: str, base_region: str = "us-east-1"
+    ) -> float:
         """
         Get regional pricing multiplier by comparing real AWS pricing between regions.
-        
+
         Args:
             service_key: Service identifier (nat_gateway, elastic_ip, etc.)
             target_region: Target region to get multiplier for
             base_region: Base region for comparison (default us-east-1)
-            
+
         Returns:
             Regional pricing multiplier (target_price / base_price)
         """
         cache_key = f"{service_key}:{target_region}:{base_region}"
-        
+
         with self._region_cache_lock:
             # Check cache first
             if cache_key in self._regional_pricing_cache:
                 cached_result = self._regional_pricing_cache[cache_key]
-                if datetime.now() - cached_result['last_updated'] < self.cache_ttl:
+                if datetime.now() - cached_result["last_updated"] < self.cache_ttl:
                     logger.debug(f"Using cached regional multiplier for {service_key} {target_region}")
-                    return cached_result['multiplier']
+                    return cached_result["multiplier"]
                 else:
                     # Cache expired, remove it
                     del self._regional_pricing_cache[cache_key]
-        
+
         try:
             # Get real pricing for both regions
             base_pricing = self._get_aws_api_pricing(service_key, base_region)
             target_pricing = self._get_aws_api_pricing(service_key, target_region)
-            
+
             # Calculate multiplier
             if base_pricing.monthly_cost > 0:
                 multiplier = target_pricing.monthly_cost / base_pricing.monthly_cost
             else:
                 multiplier = 1.0
-                
+
             # Cache the result
             with self._region_cache_lock:
                 self._regional_pricing_cache[cache_key] = {
-                    'multiplier': multiplier,
-                    'last_updated': datetime.now(),
-                    'base_cost': base_pricing.monthly_cost,
-                    'target_cost': target_pricing.monthly_cost
+                    "multiplier": multiplier,
+                    "last_updated": datetime.now(),
+                    "base_cost": base_pricing.monthly_cost,
+                    "target_cost": target_pricing.monthly_cost,
                 }
-            
+
             logger.info(f"Regional multiplier for {service_key} {target_region}: {multiplier:.4f}")
             return multiplier
-            
+
         except Exception as e:
             logger.warning(f"Failed to get regional pricing multiplier for {service_key} {target_region}: {e}")
-            
+
             # Fallback: Return 1.0 (no multiplier) to avoid hardcoded values
             logger.warning(f"Using 1.0 multiplier for {service_key} {target_region} - investigate pricing API access")
             return 1.0
@@ -1192,44 +1195,54 @@ class DynamicAWSPricing:
             total_entries = len(self._pricing_cache)
             api_entries = sum(1 for r in self._pricing_cache.values() if r.pricing_source == "aws_api")
             fallback_entries = sum(1 for r in self._pricing_cache.values() if r.pricing_source == "fallback")
-            
+
             return {
                 "total_cached_entries": total_entries,
                 "aws_api_entries": api_entries,
                 "fallback_entries": fallback_entries,
                 "cache_hit_rate": (api_entries / total_entries * 100) if total_entries > 0 else 0,
-                "cache_ttl_hours": self.cache_ttl.total_seconds() / 3600
+                "cache_ttl_hours": self.cache_ttl.total_seconds() / 3600,
             }
 
     def get_available_regions(self) -> List[str]:
         """
         Get all available AWS regions dynamically from AWS API.
-        
+
         Returns:
             List of AWS region codes
         """
         try:
             if self.profile:
-                session = create_cost_session(self.profile)
-                ec2_client = session.client('ec2', region_name='us-east-1')
+                session = create_cost_session(profile_name=self.profile)
+                ec2_client = session.client("ec2", region_name="us-east-1")
             else:
-                ec2_client = boto3.client('ec2', region_name='us-east-1')
-                
+                ec2_client = boto3.client("ec2", region_name="us-east-1")
+
             response = ec2_client.describe_regions()
-            regions = [region['RegionName'] for region in response['Regions']]
-            
+            regions = [region["RegionName"] for region in response["Regions"]]
+
             logger.info(f"Retrieved {len(regions)} AWS regions from API")
             return sorted(regions)
-            
+
         except Exception as e:
             logger.warning(f"Failed to get regions from AWS API: {e}")
-            
+
             # Fallback to well-known regions if API unavailable
             fallback_regions = [
-                'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
-                'eu-central-1', 'eu-west-1', 'eu-west-2', 'eu-west-3',
-                'ap-northeast-1', 'ap-northeast-2', 'ap-southeast-1', 'ap-southeast-2',
-                'ca-central-1', 'sa-east-1'
+                "us-east-1",
+                "us-east-2",
+                "us-west-1",
+                "us-west-2",
+                "eu-central-1",
+                "eu-west-1",
+                "eu-west-2",
+                "eu-west-3",
+                "ap-northeast-1",
+                "ap-northeast-2",
+                "ap-southeast-1",
+                "ap-southeast-2",
+                "ca-central-1",
+                "sa-east-1",
             ]
             logger.info(f"Using fallback regions: {len(fallback_regions)} regions")
             return fallback_regions
@@ -1239,11 +1252,11 @@ class DynamicAWSPricing:
         with self._cache_lock:
             cleared_count = len(self._pricing_cache)
             self._pricing_cache.clear()
-            
+
         with self._region_cache_lock:
             regional_cleared = len(self._regional_pricing_cache)
             self._regional_pricing_cache.clear()
-            
+
         logger.info(f"Cleared {cleared_count} pricing cache entries and {regional_cleared} regional cache entries")
 
 
@@ -1252,36 +1265,34 @@ _pricing_engine = None
 _pricing_lock = threading.Lock()
 
 
-def get_aws_pricing_engine(cache_ttl_hours: int = 24, enable_fallback: bool = True, profile: Optional[str] = None) -> DynamicAWSPricing:
+def get_aws_pricing_engine(
+    cache_ttl_hours: int = 24, enable_fallback: bool = True, profile: Optional[str] = None
+) -> DynamicAWSPricing:
     """
     Get AWS pricing engine instance with enterprise profile integration.
-    
+
     Args:
         cache_ttl_hours: Cache time-to-live in hours
         enable_fallback: Enable fallback to estimated pricing
         profile: AWS profile for pricing operations (enterprise integration)
-        
+
     Returns:
         DynamicAWSPricing instance
     """
     # Create instance per profile for enterprise multi-profile support
     # This ensures profile isolation and prevents cross-profile cache contamination
-    return DynamicAWSPricing(
-        cache_ttl_hours=cache_ttl_hours,
-        enable_fallback=enable_fallback,
-        profile=profile
-    )
+    return DynamicAWSPricing(cache_ttl_hours=cache_ttl_hours, enable_fallback=enable_fallback, profile=profile)
 
 
 def get_service_monthly_cost(service_key: str, region: str = "us-east-1", profile: Optional[str] = None) -> float:
     """
     Convenience function to get monthly cost for AWS service with profile support.
-    
+
     Args:
         service_key: Service identifier
         region: AWS region
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Monthly cost in USD
     """
@@ -1293,33 +1304,35 @@ def get_service_monthly_cost(service_key: str, region: str = "us-east-1", profil
 def calculate_annual_cost(monthly_cost: float) -> float:
     """
     Calculate annual cost from monthly cost.
-    
+
     Args:
         monthly_cost: Monthly cost in USD
-        
+
     Returns:
         Annual cost in USD
     """
     return monthly_cost * 12
 
 
-def calculate_regional_cost(base_cost: float, region: str, service_key: str = "nat_gateway", profile: Optional[str] = None) -> float:
+def calculate_regional_cost(
+    base_cost: float, region: str, service_key: str = "nat_gateway", profile: Optional[str] = None
+) -> float:
     """
     Apply dynamic regional pricing multiplier to base cost using AWS Pricing API.
-    
+
     Args:
         base_cost: Base cost in USD
         region: AWS region
         service_key: Service type for regional multiplier calculation
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Region-adjusted cost in USD
     """
     if region == "us-east-1":
         # Base region - no multiplier needed
         return base_cost
-        
+
     pricing_engine = get_aws_pricing_engine(profile=profile)
     multiplier = pricing_engine.get_regional_pricing_multiplier(service_key, region, "us-east-1")
     return base_cost * multiplier
@@ -1328,12 +1341,12 @@ def calculate_regional_cost(base_cost: float, region: str, service_key: str = "n
 def get_ec2_monthly_cost(instance_type: str, region: str = "us-east-1", profile: Optional[str] = None) -> float:
     """
     Convenience function to get monthly cost for EC2 instance type with profile support.
-    
+
     Args:
         instance_type: EC2 instance type (e.g., t3.micro)
         region: AWS region
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Monthly cost in USD
     """
@@ -1342,26 +1355,28 @@ def get_ec2_monthly_cost(instance_type: str, region: str = "us-east-1", profile:
     return result.monthly_cost
 
 
-def calculate_ec2_cost_impact(instance_type: str, count: int = 1, region: str = "us-east-1", profile: Optional[str] = None) -> Dict[str, float]:
+def calculate_ec2_cost_impact(
+    instance_type: str, count: int = 1, region: str = "us-east-1", profile: Optional[str] = None
+) -> Dict[str, float]:
     """
     Calculate cost impact for multiple EC2 instances with profile support.
-    
+
     Args:
         instance_type: EC2 instance type
         count: Number of instances
         region: AWS region
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Dictionary with cost calculations
     """
     monthly_cost_per_instance = get_ec2_monthly_cost(instance_type, region, profile)
-    
+
     return {
         "monthly_cost_per_instance": monthly_cost_per_instance,
         "total_monthly_cost": monthly_cost_per_instance * count,
         "total_annual_cost": monthly_cost_per_instance * count * 12,
-        "instance_count": count
+        "instance_count": count,
     }
 
 
@@ -1369,6 +1384,7 @@ def calculate_ec2_cost_impact(instance_type: str, count: int = 1, region: str =
 # ENTERPRISE CONVENIENCE FUNCTIONS - Strategic Requirements Integration
 # ============================================================================
 
+
 def get_ec2_instance_hourly_cost(instance_type: str, region: str = "us-east-1", profile: Optional[str] = None) -> float:
     """Enterprise convenience function for EC2 hourly cost (Strategic Requirement #1)."""
     pricing_engine = get_aws_pricing_engine(profile=profile)
@@ -1387,73 +1403,85 @@ def get_nat_gateway_monthly_cost(region: str = "us-east-1", profile: Optional[st
     return pricing_engine.get_nat_gateway_monthly_cost(region)
 
 
-def get_ebs_gb_monthly_cost(volume_type: str = "gp3", region: str = "us-east-1", profile: Optional[str] = None) -> float:
+def get_ebs_gb_monthly_cost(
+    volume_type: str = "gp3", region: str = "us-east-1", profile: Optional[str] = None
+) -> float:
     """Enterprise convenience function for EBS per-GB monthly cost (Strategic Requirement #4)."""
     pricing_engine = get_aws_pricing_engine(profile=profile)
     return pricing_engine.get_ebs_gb_monthly_cost(volume_type, region)
 
 
-def get_multi_service_cost_analysis(regions: List[str], services: Optional[List[str]] = None, profile: Optional[str] = None) -> Dict[str, Dict[str, float]]:
+def get_multi_service_cost_analysis(
+    regions: List[str], services: Optional[List[str]] = None, profile: Optional[str] = None
+) -> Dict[str, Dict[str, float]]:
     """
     Enterprise function for multi-region, multi-service cost analysis with <1s performance.
-    
+
     Args:
         regions: List of AWS regions to analyze
         services: List of service keys (default: common enterprise services)
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Dictionary mapping region to service costs
     """
     if services is None:
         services = ["nat_gateway", "elastic_ip", "ebs_gp3", "vpc_endpoint", "loadbalancer_application"]
-    
+
     pricing_engine = get_aws_pricing_engine(profile=profile)
     results = {}
-    
+
     for region in regions:
         service_requests = [(service, region) for service in services]
         pricing_results = pricing_engine.get_multi_service_pricing(service_requests)
-        
+
         results[region] = {
-            service: pricing_results.get(f"{service}:{region}", AWSPricingResult(
-                service_key=service, region=region, monthly_cost=0.0, 
-                pricing_source="error", last_updated=datetime.now()
-            )).monthly_cost
+            service: pricing_results.get(
+                f"{service}:{region}",
+                AWSPricingResult(
+                    service_key=service,
+                    region=region,
+                    monthly_cost=0.0,
+                    pricing_source="error",
+                    last_updated=datetime.now(),
+                ),
+            ).monthly_cost
             for service in services
         }
-    
+
     return results
 
 
 def warm_pricing_cache_for_enterprise(regions: List[str], profile: Optional[str] = None) -> None:
     """
     Enterprise cache warming for optimal <1s response times across regions.
-    
+
     Args:
         regions: List of AWS regions to warm cache for
         profile: AWS profile for enterprise --profile compatibility
     """
     pricing_engine = get_aws_pricing_engine(profile=profile)
-    
+
     console.print(f"[dim]Warming enterprise pricing cache for {len(regions)} regions...[/]")
-    
+
     for region in regions:
         pricing_engine.warm_cache_for_region(region)
-    
+
     console.print("[dim]Enterprise pricing cache warming completed[/]")
 
 
-def get_regional_pricing_multiplier(service_key: str, target_region: str, base_region: str = "us-east-1", profile: Optional[str] = None) -> float:
+def get_regional_pricing_multiplier(
+    service_key: str, target_region: str, base_region: str = "us-east-1", profile: Optional[str] = None
+) -> float:
     """
     Get dynamic regional pricing multiplier using AWS Pricing API.
-    
+
     Args:
         service_key: Service identifier (nat_gateway, elastic_ip, etc.)
         target_region: Target region to get multiplier for
         base_region: Base region for comparison (default us-east-1)
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Regional pricing multiplier (target_price / base_price)
     """
@@ -1464,58 +1492,53 @@ def get_regional_pricing_multiplier(service_key: str, target_region: str, base_r
 def get_all_regions_pricing(service_key: str, profile: Optional[str] = None) -> Dict[str, float]:
     """
     Get pricing for a service across all AWS regions dynamically.
-    
+
     Args:
         service_key: Service identifier
         profile: AWS profile for enterprise --profile compatibility
-        
+
     Returns:
         Dictionary mapping region to monthly cost
     """
     pricing_engine = get_aws_pricing_engine(profile=profile)
     regions = pricing_engine.get_available_regions()
-    
+
     results = {}
     service_requests = [(service_key, region) for region in regions]
     pricing_results = pricing_engine.get_multi_service_pricing(service_requests)
-    
+
     for region in regions:
         key = f"{service_key}:{region}"
         if key in pricing_results:
             results[region] = pricing_results[key].monthly_cost
         else:
             results[region] = 0.0
-            
+
     return results
 
 
 # Export main functions
 __all__ = [
     # Core Classes
-    'DynamicAWSPricing',
-    'AWSPricingResult',
-    
+    "DynamicAWSPricing",
+    "AWSPricingResult",
     # Core Factory Functions
-    'get_aws_pricing_engine',
-    
+    "get_aws_pricing_engine",
     # General Service Functions
-    'get_service_monthly_cost',
-    'get_ec2_monthly_cost',
-    'calculate_ec2_cost_impact',
-    'calculate_annual_cost',
-    'calculate_regional_cost',
-    
+    "get_service_monthly_cost",
+    "get_ec2_monthly_cost",
+    "calculate_ec2_cost_impact",
+    "calculate_annual_cost",
+    "calculate_regional_cost",
     # Strategic Requirements - Enterprise Service Methods
-    'get_ec2_instance_hourly_cost',  # Strategic Requirement #1
-    'get_eip_monthly_cost',          # Strategic Requirement #2
-    'get_nat_gateway_monthly_cost',  # Strategic Requirement #3
-    'get_ebs_gb_monthly_cost',       # Strategic Requirement #4
-    
+    "get_ec2_instance_hourly_cost",  # Strategic Requirement #1
+    "get_eip_monthly_cost",  # Strategic Requirement #2
+    "get_nat_gateway_monthly_cost",  # Strategic Requirement #3
+    "get_ebs_gb_monthly_cost",  # Strategic Requirement #4
     # Enterprise Performance Functions
-    'get_multi_service_cost_analysis',
-    'warm_pricing_cache_for_enterprise',
-    
+    "get_multi_service_cost_analysis",
+    "warm_pricing_cache_for_enterprise",
     # Dynamic Regional Pricing Functions
-    'get_regional_pricing_multiplier',
-    'get_all_regions_pricing'
-]
+    "get_regional_pricing_multiplier",
+    "get_all_regions_pricing",
+]