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

runbooks/vpc/heatmap_engine.py

@@ -17,6 +17,7 @@ from .cost_engine import NetworkingCostEngine
 from ..common.env_utils import get_required_env_float
 from ..common.aws_pricing_api import AWSPricingAPI
 from ..common.rich_utils import console
+from ..common.aws_profile_manager import AWSProfileManager, get_current_account_id
 
 logger = logging.getLogger(__name__)
 
@@ -107,7 +108,6 @@ class NetworkingCostHeatMapEngine:
         # Heat map data storage
         self.heat_map_data = {}
 
-
     def _initialize_aws_sessions(self):
         """Initialize AWS sessions for all profiles"""
         profiles = {
@@ -184,8 +184,9 @@ class NetworkingCostHeatMapEngine:
         """Generate detailed single account heat map"""
         logger.info("Generating single account heat map")
 
-        # Use environment-driven account ID for universal compatibility
-        account_id = os.getenv("AWS_ACCOUNT_ID", "123456789012")
+        # Use dynamic account ID resolution for universal compatibility
+        profile_manager = AWSProfileManager(self.config.profile if hasattr(self.config, "profile") else None)
+        account_id = profile_manager.get_account_id()
 
         # Create cost distribution matrix
         heat_map_matrix = np.zeros((len(self.config.regions), len(NETWORKING_SERVICES)))
@@ -240,18 +241,31 @@ class NetworkingCostHeatMapEngine:
 
         # Account categories with dynamic environment configuration
         account_categories = {
-            "production": {"count": int(os.getenv("AWS_PROD_ACCOUNTS", "15")), "cost_multiplier": float(os.getenv("PROD_COST_MULTIPLIER", "5.0"))},
-            "staging": {"count": int(os.getenv("AWS_STAGING_ACCOUNTS", "15")), "cost_multiplier": float(os.getenv("STAGING_COST_MULTIPLIER", "2.0"))},
-            "development": {"count": int(os.getenv("AWS_DEV_ACCOUNTS", "20")), "cost_multiplier": float(os.getenv("DEV_COST_MULTIPLIER", "1.0"))},
-            "sandbox": {"count": int(os.getenv("AWS_SANDBOX_ACCOUNTS", "10")), "cost_multiplier": float(os.getenv("SANDBOX_COST_MULTIPLIER", "0.3"))},
+            "production": {
+                "count": int(os.getenv("AWS_PROD_ACCOUNTS", "15")),
+                "cost_multiplier": float(os.getenv("PROD_COST_MULTIPLIER", "5.0")),
+            },
+            "staging": {
+                "count": int(os.getenv("AWS_STAGING_ACCOUNTS", "15")),
+                "cost_multiplier": float(os.getenv("STAGING_COST_MULTIPLIER", "2.0")),
+            },
+            "development": {
+                "count": int(os.getenv("AWS_DEV_ACCOUNTS", "20")),
+                "cost_multiplier": float(os.getenv("DEV_COST_MULTIPLIER", "1.0")),
+            },
+            "sandbox": {
+                "count": int(os.getenv("AWS_SANDBOX_ACCOUNTS", "10")),
+                "cost_multiplier": float(os.getenv("SANDBOX_COST_MULTIPLIER", "0.3")),
+            },
         }
 
         # Generate aggregated matrix
         aggregated_matrix = np.zeros((len(self.config.regions), len(NETWORKING_SERVICES)))
         account_breakdown = []
 
-        # Dynamic base account ID from environment for universal compatibility
-        account_id = int(os.getenv("AWS_BASE_ACCOUNT_ID", "100000000000"))
+        # Dynamic base account ID from current AWS credentials
+        profile_manager = AWSProfileManager(self.config.profile if hasattr(self.config, "profile") else None)
+        account_id = int(profile_manager.get_account_id())
 
         for category, details in account_categories.items():
             for i in range(details["count"]):
@@ -269,7 +283,9 @@ class NetworkingCostHeatMapEngine:
                             "category": category,
                             "monthly_cost": float(np.sum(account_matrix)),
                             "primary_region": self.config.regions[int(np.argmax(np.sum(account_matrix, axis=1)))],
-                            "top_service": list(NETWORKING_SERVICES.keys())[int(np.argmax(np.sum(account_matrix, axis=0)))],
+                            "top_service": list(NETWORKING_SERVICES.keys())[
+                                int(np.argmax(np.sum(account_matrix, axis=0)))
+                            ],
                         }
                     )
 
@@ -425,7 +441,7 @@ class NetworkingCostHeatMapEngine:
 
             for region in self.config.regions:
                 # Dynamic cost calculation with real AWS Cost Explorer integration
-                if hasattr(self, 'cost_engine') and self.cost_engine and self.cost_explorer_available:
+                if hasattr(self, "cost_engine") and self.cost_engine and self.cost_explorer_available:
                     # Real AWS Cost Explorer data
                     base_cost = self.cost_engine.get_service_cost(service_key, region)
                 else:
@@ -537,14 +553,14 @@ class NetworkingCostHeatMapEngine:
 
         # Apply costs based on pattern using dynamic pricing (NO hardcoded fallbacks)
         region = self.config.regions[0] if self.config.regions else "us-east-1"  # Use first configured region
-        
+
         # Get dynamic service pricing
         service_pricing = self._get_dynamic_service_pricing(region)
-        
+
         for service_idx, service_key in enumerate(NETWORKING_SERVICES.keys()):
             for region_idx in range(len(self.config.regions)):
                 cost = 0.0  # Default to free
-                
+
                 # Only apply costs if we have valid pricing data
                 if service_key in service_pricing and service_pricing[service_key] > 0:
                     if service_key == "nat_gateway" and region_idx < pattern["nat_gateways"]:
@@ -555,7 +571,7 @@ class NetworkingCostHeatMapEngine:
                         cost = service_pricing[service_key] * multiplier
                     elif service_key == "elastic_ip" and region_idx < pattern.get("elastic_ips", 0):
                         cost = service_pricing[service_key] * multiplier
-                
+
                 matrix[region_idx, service_idx] = cost
 
         return matrix
@@ -607,7 +623,7 @@ class NetworkingCostHeatMapEngine:
     def _calculate_dynamic_baseline_cost(self, service_key: str, region: str) -> float:
         """
         Calculate dynamic baseline costs using AWS pricing patterns and region multipliers.
-        
+
         This replaces hardcoded values with calculation based on:
         - AWS pricing calculator patterns
         - Regional pricing differences
@@ -615,66 +631,68 @@ class NetworkingCostHeatMapEngine:
         """
         # Regional cost multipliers based on AWS pricing
         regional_multipliers = {
-            "us-east-1": 1.0,      # Base region (N. Virginia)
-            "us-west-2": 1.05,     # Oregon - slight premium
-            "us-west-1": 1.15,     # N. California - higher cost
-            "eu-west-1": 1.10,     # Ireland - EU pricing
+            "us-east-1": 1.0,  # Base region (N. Virginia)
+            "us-west-2": 1.05,  # Oregon - slight premium
+            "us-west-1": 1.15,  # N. California - higher cost
+            "eu-west-1": 1.10,  # Ireland - EU pricing
             "eu-central-1": 1.12,  # Frankfurt - slightly higher
-            "eu-west-2": 1.08,     # London - competitive EU pricing
-            "ap-southeast-1": 1.18, # Singapore - APAC premium
-            "ap-southeast-2": 1.16, # Sydney - competitive APAC
-            "ap-northeast-1": 1.20, # Tokyo - highest APAC
+            "eu-west-2": 1.08,  # London - competitive EU pricing
+            "ap-southeast-1": 1.18,  # Singapore - APAC premium
+            "ap-southeast-2": 1.16,  # Sydney - competitive APAC
+            "ap-northeast-1": 1.20,  # Tokyo - highest APAC
         }
-        
+
         # AWS service pricing patterns (monthly USD) - DYNAMIC PRICING REQUIRED
         # ENTERPRISE COMPLIANCE: All pricing must be fetched from AWS Pricing API
         service_base_costs = self._get_dynamic_service_pricing(region)
-        
+
         base_cost = service_base_costs.get(service_key, 0.0)
         region_multiplier = regional_multipliers.get(region, 1.0)
-        
+
         return base_cost * region_multiplier
 
     def _get_dynamic_service_pricing(self, region: str) -> Dict[str, float]:
         """
         Get dynamic AWS service pricing following enterprise cascade:
-        
-        a. ✅ Try Runbooks API with boto3 (dynamic) 
+
+        a. ✅ Try Runbooks API with boto3 (dynamic)
         b. ✅ Try MCP-Servers (dynamic) & gaps analysis with real AWS data
            → If failed, identify WHY option 'a' didn't work, then UPGRADE option 'a'
         c. ✅ Fail gracefully with user guidance (NO hardcoded fallback)
-        
+
         ENTERPRISE COMPLIANCE: Zero tolerance for hardcoded pricing fallbacks.
-        
+
         Args:
             region: AWS region for pricing lookup
-            
+
         Returns:
             Dictionary of service pricing (monthly USD)
         """
         service_costs = {}
         pricing_errors = []
-        
+
         # VPC itself is always free
         service_costs["vpc"] = 0.0
-        
+
         # Step A: Try Runbooks Pricing API (Enhanced)
         console.print(f"[blue]🔄 Step A: Attempting Runbooks Pricing API for {region}[/blue]")
         try:
             from ..common.aws_pricing_api import AWSPricingAPI
-            
+
             # Initialize with proper session management
-            profile = getattr(self, 'profile', None)
+            profile = getattr(self, "profile", None)
             pricing_api = AWSPricingAPI(profile=profile)
-            
+
             # NAT Gateway pricing (primary VPC cost component)
             try:
                 service_costs["nat_gateway"] = pricing_api.get_nat_gateway_monthly_cost(region)
-                console.print(f"[green]✅ NAT Gateway pricing: ${service_costs['nat_gateway']:.2f}/month from Runbooks API[/green]")
+                console.print(
+                    f"[green]✅ NAT Gateway pricing: ${service_costs['nat_gateway']:.2f}/month from Runbooks API[/green]"
+                )
             except Exception as e:
                 pricing_errors.append(f"NAT Gateway: {str(e)}")
                 logger.warning(f"Runbooks API NAT Gateway pricing failed: {e}")
-            
+
             # Try other services with existing API methods
             for service_key in ["vpc_endpoint", "transit_gateway", "elastic_ip"]:
                 try:
@@ -682,20 +700,22 @@ class NetworkingCostHeatMapEngine:
                     if hasattr(pricing_api, f"get_{service_key}_monthly_cost"):
                         method = getattr(pricing_api, f"get_{service_key}_monthly_cost")
                         service_costs[service_key] = method(region)
-                        console.print(f"[green]✅ {service_key} pricing: ${service_costs[service_key]:.2f}/month from Runbooks API[/green]")
+                        console.print(
+                            f"[green]✅ {service_key} pricing: ${service_costs[service_key]:.2f}/month from Runbooks API[/green]"
+                        )
                     else:
                         pricing_errors.append(f"{service_key}: API method not implemented")
                 except Exception as e:
                     pricing_errors.append(f"{service_key}: {str(e)}")
-            
+
             # Data transfer pricing (if API available)
             if "data_transfer" not in service_costs:
                 pricing_errors.append("data_transfer: API method not implemented")
-            
+
         except Exception as e:
             pricing_errors.append(f"Runbooks API initialization failed: {str(e)}")
             console.print(f"[yellow]⚠️ Runbooks Pricing API unavailable: {e}[/yellow]")
-        
+
         # Step B: MCP Gap Analysis & Validation
         console.print(f"[blue]🔄 Step B: MCP Gap Analysis for missing pricing data[/blue]")
         try:
@@ -703,39 +723,41 @@ class NetworkingCostHeatMapEngine:
             for required_service in ["nat_gateway", "vpc_endpoint", "transit_gateway", "elastic_ip", "data_transfer"]:
                 if required_service not in service_costs:
                     missing_services.append(required_service)
-            
+
             if missing_services:
                 # Use MCP to identify why Runbooks API failed
                 mcp_analysis = self._perform_mcp_pricing_gap_analysis(missing_services, region, pricing_errors)
-                
+
                 # Display MCP analysis results
                 console.print(f"[cyan]📊 MCP Gap Analysis Results:[/cyan]")
                 for service, analysis in mcp_analysis.items():
-                    if analysis.get('mcp_validated_cost'):
-                        service_costs[service] = analysis['mcp_validated_cost']
-                        console.print(f"[green]✅ {service}: ${analysis['mcp_validated_cost']:.2f}/month via MCP validation[/green]")
+                    if analysis.get("mcp_validated_cost"):
+                        service_costs[service] = analysis["mcp_validated_cost"]
+                        console.print(
+                            f"[green]✅ {service}: ${analysis['mcp_validated_cost']:.2f}/month via MCP validation[/green]"
+                        )
                     else:
                         console.print(f"[yellow]⚠️ {service}: {analysis.get('gap_reason', 'Unknown gap')}[/yellow]")
-            
+
         except Exception as e:
             pricing_errors.append(f"MCP gap analysis failed: {str(e)}")
             console.print(f"[yellow]⚠️ MCP gap analysis failed: {e}[/yellow]")
-        
+
         # Step C: Graceful Failure with User Guidance (NO hardcoded fallback)
         missing_services = []
         for required_service in ["nat_gateway", "vpc_endpoint", "transit_gateway", "elastic_ip", "data_transfer"]:
             if required_service not in service_costs:
                 missing_services.append(required_service)
-        
+
         if missing_services:
             console.print(f"[red]🚫 ENTERPRISE COMPLIANCE: Cannot proceed with missing pricing data[/red]")
-            
+
             # Generate comprehensive guidance
             self._provide_pricing_resolution_guidance(missing_services, pricing_errors, region)
-            
+
             # Return empty dict to signal failure - DO NOT use hardcoded fallback
             return {"vpc": 0.0}  # Only VPC (free) can be returned
-        
+
         logger.info(f"✅ Successfully retrieved all service pricing for region: {region}")
         console.print(f"[green]✅ Complete dynamic pricing loaded for {region} - {len(service_costs)} services[/green]")
         return service_costs
@@ -743,222 +765,228 @@ class NetworkingCostHeatMapEngine:
     def _calculate_dynamic_base_daily_cost(self) -> float:
         """
         Calculate dynamic base daily cost from current pricing data.
-        
+
         Returns:
             Daily cost estimate based on dynamic pricing, or 0.0 if unavailable
         """
         try:
             # Use primary region for calculation
             region = self.config.regions[0] if self.config.regions else "us-east-1"
-            
+
             # Get dynamic service pricing
             service_pricing = self._get_dynamic_service_pricing(region)
-            
+
             if not service_pricing or len(service_pricing) <= 1:  # Only VPC (free) available
                 console.print(f"[yellow]⚠️ No dynamic pricing available for daily cost calculation[/yellow]")
                 return 0.0
-            
+
             # Calculate daily cost from monthly costs
             monthly_total = sum(cost for cost in service_pricing.values() if cost > 0)
             daily_cost = monthly_total / 30.0  # Convert monthly to daily
-            
-            console.print(f"[cyan]📊 Dynamic daily cost calculated: ${daily_cost:.2f}/day from available services[/cyan]")
+
+            console.print(
+                f"[cyan]📊 Dynamic daily cost calculated: ${daily_cost:.2f}/day from available services[/cyan]"
+            )
             return daily_cost
-            
+
         except Exception as e:
             logger.warning(f"Dynamic daily cost calculation failed: {e}")
             console.print(f"[yellow]⚠️ Dynamic daily cost calculation failed: {e}[/yellow]")
             return 0.0
 
-    def _perform_mcp_pricing_gap_analysis(self, missing_services: List[str], region: str, pricing_errors: List[str]) -> Dict[str, Dict[str, Any]]:
+    def _perform_mcp_pricing_gap_analysis(
+        self, missing_services: List[str], region: str, pricing_errors: List[str]
+    ) -> Dict[str, Dict[str, Any]]:
         """
         Perform MCP gap analysis to identify why Runbooks API failed and validate alternatives.
-        
+
         Args:
             missing_services: List of services missing pricing data
             region: AWS region for analysis
             pricing_errors: List of errors from previous attempts
-            
+
         Returns:
             Dictionary of gap analysis results per service
         """
         gap_analysis = {}
-        
+
         try:
             # Initialize MCP integration if available
             from ..common.mcp_integration import EnterpriseMCPIntegrator
-            
+
             # Get profile for MCP integration
-            profile = getattr(self, 'profile', None)
+            profile = getattr(self, "profile", None)
             mcp_integrator = EnterpriseMCPIntegrator(user_profile=profile, console_instance=console)
-            
+
             console.print(f"[cyan]🔍 MCP analyzing {len(missing_services)} missing services...[/cyan]")
-            
+
             for service in missing_services:
                 analysis = {
-                    'service': service,
-                    'mcp_validated_cost': None,
-                    'gap_reason': None,
-                    'resolution_steps': [],
-                    'cost_explorer_available': False
+                    "service": service,
+                    "mcp_validated_cost": None,
+                    "gap_reason": None,
+                    "resolution_steps": [],
+                    "cost_explorer_available": False,
                 }
-                
+
                 try:
                     # Step 1: Try Cost Explorer for historical cost data
-                    if 'billing' in mcp_integrator.aws_sessions:
-                        billing_session = mcp_integrator.aws_sessions['billing']
-                        cost_client = billing_session.client('ce')
-                        
+                    if "billing" in mcp_integrator.aws_sessions:
+                        billing_session = mcp_integrator.aws_sessions["billing"]
+                        cost_client = billing_session.client("ce")
+
                         # Query for service-specific historical costs
                         historical_cost = self._query_cost_explorer_for_service(cost_client, service, region)
-                        
+
                         if historical_cost > 0:
-                            analysis['mcp_validated_cost'] = historical_cost
-                            analysis['cost_explorer_available'] = True
-                            console.print(f"[green]✅ MCP: {service} cost validated via Cost Explorer: ${historical_cost:.2f}/month[/green]")
+                            analysis["mcp_validated_cost"] = historical_cost
+                            analysis["cost_explorer_available"] = True
+                            console.print(
+                                f"[green]✅ MCP: {service} cost validated via Cost Explorer: ${historical_cost:.2f}/month[/green]"
+                            )
                         else:
-                            analysis['gap_reason'] = f"No historical cost data found in Cost Explorer for {service}"
-                    
+                            analysis["gap_reason"] = f"No historical cost data found in Cost Explorer for {service}"
+
                     # Step 2: Analyze why Runbooks API failed for this service
                     service_errors = [err for err in pricing_errors if service in err.lower()]
                     if service_errors:
-                        analysis['gap_reason'] = f"Runbooks API issue: {service_errors[0]}"
-                        
+                        analysis["gap_reason"] = f"Runbooks API issue: {service_errors[0]}"
+
                         # Determine resolution steps based on error pattern
-                        if 'not implemented' in service_errors[0]:
-                            analysis['resolution_steps'] = [
+                        if "not implemented" in service_errors[0]:
+                            analysis["resolution_steps"] = [
                                 f"Add get_{service}_monthly_cost() method to AWSPricingAPI class",
                                 f"Implement AWS Pricing API query for {service}",
-                                "Test with enterprise profiles"
+                                "Test with enterprise profiles",
                             ]
-                        elif 'permission' in service_errors[0].lower() or 'access' in service_errors[0].lower():
-                            analysis['resolution_steps'] = [
+                        elif "permission" in service_errors[0].lower() or "access" in service_errors[0].lower():
+                            analysis["resolution_steps"] = [
                                 "Add pricing:GetProducts permission to IAM policy",
                                 "Ensure profile has Cost Explorer access",
-                                f"Test pricing API access for {region} region"
+                                f"Test pricing API access for {region} region",
                             ]
-                    
+
                 except Exception as e:
-                    analysis['gap_reason'] = f"MCP analysis failed: {str(e)}"
+                    analysis["gap_reason"] = f"MCP analysis failed: {str(e)}"
                     logger.warning(f"MCP gap analysis failed for {service}: {e}")
-                
+
                 gap_analysis[service] = analysis
-            
+
             return gap_analysis
-            
+
         except ImportError:
             console.print(f"[yellow]⚠️ MCP integration not available - basic gap analysis only[/yellow]")
             # Provide basic gap analysis without MCP
             for service in missing_services:
                 gap_analysis[service] = {
-                    'service': service,
-                    'mcp_validated_cost': None,
-                    'gap_reason': 'MCP integration not available',
-                    'resolution_steps': [
-                        'Install MCP dependencies',
-                        'Configure MCP integration',
-                        'Retry with MCP validation'
-                    ]
+                    "service": service,
+                    "mcp_validated_cost": None,
+                    "gap_reason": "MCP integration not available",
+                    "resolution_steps": [
+                        "Install MCP dependencies",
+                        "Configure MCP integration",
+                        "Retry with MCP validation",
+                    ],
                 }
             return gap_analysis
-        
+
         except Exception as e:
             console.print(f"[yellow]⚠️ MCP gap analysis error: {e}[/yellow]")
             # Return basic analysis on error
             for service in missing_services:
                 gap_analysis[service] = {
-                    'service': service,
-                    'mcp_validated_cost': None,
-                    'gap_reason': f'MCP analysis error: {str(e)}',
-                    'resolution_steps': ['Check MCP configuration', 'Verify AWS profiles', 'Retry analysis']
+                    "service": service,
+                    "mcp_validated_cost": None,
+                    "gap_reason": f"MCP analysis error: {str(e)}",
+                    "resolution_steps": ["Check MCP configuration", "Verify AWS profiles", "Retry analysis"],
                 }
             return gap_analysis
 
     def _query_cost_explorer_for_service(self, cost_client, service: str, region: str) -> float:
         """
         Query Cost Explorer for historical service costs to validate pricing.
-        
+
         Args:
             cost_client: Boto3 Cost Explorer client
             service: Service key (nat_gateway, vpc_endpoint, etc.)
             region: AWS region
-            
+
         Returns:
             Monthly cost estimate based on historical data
         """
         try:
             from datetime import datetime, timedelta
-            
+
             # Map service keys to AWS Cost Explorer service names
             service_mapping = {
-                'nat_gateway': 'Amazon Virtual Private Cloud',
-                'vpc_endpoint': 'Amazon Virtual Private Cloud', 
-                'transit_gateway': 'Amazon VPC',
-                'elastic_ip': 'Amazon Elastic Compute Cloud - Compute',
-                'data_transfer': 'Amazon CloudFront'
+                "nat_gateway": "Amazon Virtual Private Cloud",
+                "vpc_endpoint": "Amazon Virtual Private Cloud",
+                "transit_gateway": "Amazon VPC",
+                "elastic_ip": "Amazon Elastic Compute Cloud - Compute",
+                "data_transfer": "Amazon CloudFront",
             }
-            
+
             aws_service_name = service_mapping.get(service)
             if not aws_service_name:
                 return 0.0
-            
+
             # Query last 3 months for more reliable average
             end_date = datetime.now().date()
             start_date = end_date - timedelta(days=90)
-            
+
             response = cost_client.get_cost_and_usage(
-                TimePeriod={
-                    'Start': start_date.strftime('%Y-%m-%d'),
-                    'End': end_date.strftime('%Y-%m-%d')
-                },
-                Granularity='MONTHLY',
-                Metrics=['BlendedCost'],
-                GroupBy=[
-                    {'Type': 'DIMENSION', 'Key': 'SERVICE'},
-                    {'Type': 'DIMENSION', 'Key': 'REGION'}
-                ],
+                TimePeriod={"Start": start_date.strftime("%Y-%m-%d"), "End": end_date.strftime("%Y-%m-%d")},
+                Granularity="MONTHLY",
+                Metrics=["BlendedCost"],
+                GroupBy=[{"Type": "DIMENSION", "Key": "SERVICE"}, {"Type": "DIMENSION", "Key": "REGION"}],
                 Filter={
-                    'And': [
-                        {'Dimensions': {'Key': 'SERVICE', 'Values': [aws_service_name]}},
-                        {'Dimensions': {'Key': 'REGION', 'Values': [region]}}
+                    "And": [
+                        {"Dimensions": {"Key": "SERVICE", "Values": [aws_service_name]}},
+                        {"Dimensions": {"Key": "REGION", "Values": [region]}},
                     ]
-                }
+                },
             )
-            
+
             total_cost = 0.0
             months_with_data = 0
-            
-            for result in response['ResultsByTime']:
-                for group in result['Groups']:
-                    cost_amount = float(group['Metrics']['BlendedCost']['Amount'])
+
+            for result in response["ResultsByTime"]:
+                for group in result["Groups"]:
+                    cost_amount = float(group["Metrics"]["BlendedCost"]["Amount"])
                     if cost_amount > 0:
                         total_cost += cost_amount
                         months_with_data += 1
-            
+
             # Calculate average monthly cost
             if months_with_data > 0:
                 average_monthly_cost = total_cost / months_with_data
-                console.print(f"[cyan]📊 Cost Explorer: {service} average ${average_monthly_cost:.2f}/month over {months_with_data} months[/cyan]")
+                console.print(
+                    f"[cyan]📊 Cost Explorer: {service} average ${average_monthly_cost:.2f}/month over {months_with_data} months[/cyan]"
+                )
                 return average_monthly_cost
-            
+
             return 0.0
-            
+
         except Exception as e:
             logger.warning(f"Cost Explorer query failed for {service}: {e}")
             return 0.0
 
-    def _provide_pricing_resolution_guidance(self, missing_services: List[str], pricing_errors: List[str], region: str) -> None:
+    def _provide_pricing_resolution_guidance(
+        self, missing_services: List[str], pricing_errors: List[str], region: str
+    ) -> None:
         """
         Provide comprehensive guidance for resolving pricing issues.
-        
+
         Args:
             missing_services: List of services missing pricing data
             pricing_errors: List of errors encountered
             region: AWS region being analyzed
         """
         console.print(f"\n[bold red]🚫 VPC HEAT MAP PRICING RESOLUTION REQUIRED[/bold red]")
-        console.print(f"[red]Cannot generate accurate heat map without dynamic pricing for {len(missing_services)} services[/red]\n")
-        
+        console.print(
+            f"[red]Cannot generate accurate heat map without dynamic pricing for {len(missing_services)} services[/red]\n"
+        )
+
         # Display comprehensive resolution steps
         resolution_panel = f"""[bold yellow]📋 ENTERPRISE RESOLUTION STEPS:[/bold yellow]
 
@@ -969,14 +997,14 @@ class NetworkingCostHeatMapEngine:
    • ce:GetDimensionValues
    
 [bold cyan]2. Runbooks API Enhancement:[/bold cyan]
-   Missing API methods for: {', '.join(missing_services)}
+   Missing API methods for: {", ".join(missing_services)}
    
    Add to src/runbooks/common/aws_pricing_api.py:
    """
-        
+
         for service in missing_services:
             resolution_panel += f"\n   • def get_{service}_monthly_cost(self, region: str) -> float"
-        
+
         resolution_panel += f"""
 
 [bold cyan]3. Alternative Region Testing:[/bold cyan]
@@ -986,11 +1014,11 @@ class NetworkingCostHeatMapEngine:
    • --region eu-west-1 (EU support)
 
 [bold cyan]4. Enterprise Override (Temporary):[/bold cyan]"""
-        
+
         for service in missing_services:
             service_upper = service.upper()
             resolution_panel += f"\n   export AWS_PRICING_OVERRIDE_{service_upper}_MONTHLY=<cost>"
-        
+
         resolution_panel += f"""
 
 [bold cyan]5. MCP Server Integration:[/bold cyan]
@@ -1010,17 +1038,15 @@ class NetworkingCostHeatMapEngine:
 
         for i, error in enumerate(pricing_errors[:5], 1):  # Show first 5 errors
             resolution_panel += f"\n   {i}. {error}"
-        
+
         from rich.panel import Panel
+
         guidance_panel = Panel(
-            resolution_panel,
-            title="🔧 VPC Pricing Resolution Guide",
-            style="bold yellow",
-            expand=True
+            resolution_panel, title="🔧 VPC Pricing Resolution Guide", style="bold yellow", expand=True
         )
-        
+
         console.print(guidance_panel)
-        
+
         # Specific next steps
         console.print(f"\n[bold green]✅ IMMEDIATE NEXT STEPS:[/bold green]")
         console.print(f"1. Run: aws pricing get-products --service-code AmazonVPC --region {region}")
@@ -1036,7 +1062,9 @@ class NetworkingCostHeatMapEngine:
                     "total_monthly_spend": heat_maps["single_account_heat_map"]["total_monthly_cost"],
                     "total_accounts": 1,
                     "account_data": {
-                        os.getenv("AWS_ACCOUNT_ID", "123456789012"): {"monthly_cost": heat_maps["single_account_heat_map"]["total_monthly_cost"]}
+                        os.getenv("AWS_ACCOUNT_ID", "123456789012"): {
+                            "monthly_cost": heat_maps["single_account_heat_map"]["total_monthly_cost"]
+                        }
                     },
                 }
             }