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

runbooks/common/aws_pricing_api.py

@@ -16,361 +16,355 @@ from functools import lru_cache
 from datetime import datetime, timedelta
 import os
 
+
 class AWSPricingAPI:
     """Real-time AWS Pricing API integration - ZERO hardcoded values."""
-    
+
     def __init__(self, profile: Optional[str] = None):
         """Initialize with AWS Pricing API client."""
         session = boto3.Session(profile_name=profile) if profile else boto3.Session()
-        self.pricing_client = session.client('pricing', region_name='us-east-1')
-        self.ce_client = session.client('ce')  # Cost Explorer for real costs
+        self.pricing_client = session.client("pricing", region_name="us-east-1")
+        self.ce_client = session.client("ce")  # Cost Explorer for real costs
         self._cache = {}
         self._cache_expiry = {}
-        
+
     @lru_cache(maxsize=128)
-    def get_ebs_gp3_cost_per_gb(self, region: str = 'us-east-1') -> float:
+    def get_ebs_gp3_cost_per_gb(self, region: str = "us-east-1") -> float:
         """Get real-time EBS GP3 cost per GB per month from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonEC2',
+                ServiceCode="AmazonEC2",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'Storage'},
-                    {'Type': 'TERM_MATCH', 'Field': 'volumeType', 'Value': 'General Purpose'},
-                    {'Type': 'TERM_MATCH', 'Field': 'storageMedia', 'Value': 'SSD-backed'},
-                    {'Type': 'TERM_MATCH', 'Field': 'volumeApiName', 'Value': 'gp3'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(region)}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"},
+                    {"Type": "TERM_MATCH", "Field": "volumeType", "Value": "General Purpose"},
+                    {"Type": "TERM_MATCH", "Field": "storageMedia", "Value": "SSD-backed"},
+                    {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": "gp3"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'GB-month' in price_dimension.get('unit', ''):
-                            return float(price_dimension['pricePerUnit']['USD'])
-            
+                    for price_dimension in term["priceDimensions"].values():
+                        if "GB-month" in price_dimension.get("unit", ""):
+                            return float(price_dimension["pricePerUnit"]["USD"])
+
             # Fallback to Cost Explorer actual costs if Pricing API fails
-            return self._get_from_cost_explorer('EBS', 'gp3')
-            
+            return self._get_from_cost_explorer("EBS", "gp3")
+
         except Exception as e:
             # Use Cost Explorer as ultimate fallback
-            return self._get_from_cost_explorer('EBS', 'gp3')
-    
+            return self._get_from_cost_explorer("EBS", "gp3")
+
     @lru_cache(maxsize=128)
-    def get_ebs_gp2_cost_per_gb(self, region: str = 'us-east-1') -> float:
+    def get_ebs_gp2_cost_per_gb(self, region: str = "us-east-1") -> float:
         """Get real-time EBS GP2 cost per GB per month from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonEC2',
+                ServiceCode="AmazonEC2",
                 Filters=[
-                    {'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': 'location', 'Value': self._get_region_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": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'GB-month' in price_dimension.get('unit', ''):
-                            return float(price_dimension['pricePerUnit']['USD'])
-            
-            return self._get_from_cost_explorer('EBS', 'gp2')
-            
+                    for price_dimension in term["priceDimensions"].values():
+                        if "GB-month" in price_dimension.get("unit", ""):
+                            return float(price_dimension["pricePerUnit"]["USD"])
+
+            return self._get_from_cost_explorer("EBS", "gp2")
+
         except Exception:
-            return self._get_from_cost_explorer('EBS', 'gp2')
-    
+            return self._get_from_cost_explorer("EBS", "gp2")
+
     @lru_cache(maxsize=128)
-    def get_rds_snapshot_cost_per_gb(self, region: str = 'us-east-1') -> float:
+    def get_rds_snapshot_cost_per_gb(self, region: str = "us-east-1") -> float:
         """Get real-time RDS snapshot cost per GB per month from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonRDS',
+                ServiceCode="AmazonRDS",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'Storage Snapshot'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(region)}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage Snapshot"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'GB-month' in price_dimension.get('unit', ''):
-                            return float(price_dimension['pricePerUnit']['USD'])
-            
-            return self._get_from_cost_explorer('RDS', 'Snapshot')
-            
+                    for price_dimension in term["priceDimensions"].values():
+                        if "GB-month" in price_dimension.get("unit", ""):
+                            return float(price_dimension["pricePerUnit"]["USD"])
+
+            return self._get_from_cost_explorer("RDS", "Snapshot")
+
         except Exception:
-            return self._get_from_cost_explorer('RDS', 'Snapshot')
-    
+            return self._get_from_cost_explorer("RDS", "Snapshot")
+
     @lru_cache(maxsize=128)
-    def get_nat_gateway_monthly_cost(self, region: str = 'us-east-1') -> float:
+    def get_nat_gateway_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get real-time NAT Gateway monthly cost from AWS Pricing API with enterprise regional fallback."""
-        
+
         # Enterprise Regional Fallback Strategy
-        fallback_regions = ['us-east-1', 'us-west-2', 'eu-west-1']
+        fallback_regions = ["us-east-1", "us-west-2", "eu-west-1"]
         if region not in fallback_regions:
             fallback_regions.insert(0, region)
-        
+
         last_error = None
-        
+
         for attempt_region in fallback_regions:
             try:
                 # Try AWS Pricing API for this region
                 response = self.pricing_client.get_products(
-                    ServiceCode='AmazonVPC',
+                    ServiceCode="AmazonVPC",
                     Filters=[
-                        {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'NAT Gateway'},
-                        {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(attempt_region)}
+                        {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "NAT Gateway"},
+                        {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(attempt_region)},
                     ],
-                    MaxResults=1
+                    MaxResults=1,
                 )
-                
-                if response['PriceList']:
-                    price_data = json.loads(response['PriceList'][0])
-                    on_demand = price_data['terms']['OnDemand']
+
+                if response["PriceList"]:
+                    price_data = json.loads(response["PriceList"][0])
+                    on_demand = price_data["terms"]["OnDemand"]
                     for term in on_demand.values():
-                        for price_dimension in term['priceDimensions'].values():
-                            if 'Hrs' in price_dimension.get('unit', ''):
-                                hourly_rate = float(price_dimension['pricePerUnit']['USD'])
+                        for price_dimension in term["priceDimensions"].values():
+                            if "Hrs" in price_dimension.get("unit", ""):
+                                hourly_rate = float(price_dimension["pricePerUnit"]["USD"])
                                 monthly_cost = hourly_rate * 24 * 30  # Convert to monthly
                                 print(f"✅ NAT Gateway pricing: ${monthly_cost:.2f}/month from {attempt_region}")
                                 return monthly_cost
-                
+
                 # Try Cost Explorer for this region
-                ce_cost = self._get_from_cost_explorer('VPC', 'NAT Gateway', attempt_region)
+                ce_cost = self._get_from_cost_explorer("VPC", "NAT Gateway", attempt_region)
                 if ce_cost > 0:
                     print(f"✅ NAT Gateway pricing: ${ce_cost:.2f}/month from Cost Explorer")
                     return ce_cost
-                    
+
             except Exception as e:
                 last_error = e
                 print(f"⚠️ Pricing API failed for region {attempt_region}: {e}")
                 continue
-        
+
         # Enterprise fallback with graceful degradation
-        return self._get_enterprise_fallback_pricing('nat_gateway', region, last_error)
-    
+        return self._get_enterprise_fallback_pricing("nat_gateway", region, last_error)
+
     def _get_from_cost_explorer(self, service: str, resource_type: str, region: str = None) -> float:
         """Get actual costs from Cost Explorer as ultimate source of truth."""
         try:
             end_date = datetime.now()
             start_date = end_date - timedelta(days=30)
-            
+
             # Build filter with optional region
-            filter_conditions = [
-                {'Dimensions': {'Key': 'SERVICE', 'Values': [f'Amazon {service}']}}
-            ]
-            
+            filter_conditions = [{"Dimensions": {"Key": "SERVICE", "Values": [f"Amazon {service}"]}}]
+
             if region:
-                filter_conditions.append({
-                    'Dimensions': {'Key': 'REGION', 'Values': [region]}
-                })
-            
+                filter_conditions.append({"Dimensions": {"Key": "REGION", "Values": [region]}})
+
             # Add resource type filter if it helps
             if resource_type != service:
-                filter_conditions.append({
-                    'Dimensions': {'Key': 'USAGE_TYPE_GROUP', 'Values': [resource_type]}
-                })
-            
-            cost_filter = {'And': filter_conditions} if len(filter_conditions) > 1 else filter_conditions[0]
-            
+                filter_conditions.append({"Dimensions": {"Key": "USAGE_TYPE_GROUP", "Values": [resource_type]}})
+
+            cost_filter = {"And": filter_conditions} if len(filter_conditions) > 1 else filter_conditions[0]
+
             response = self.ce_client.get_cost_and_usage(
-                TimePeriod={
-                    'Start': start_date.strftime('%Y-%m-%d'),
-                    'End': end_date.strftime('%Y-%m-%d')
-                },
-                Granularity='MONTHLY',
-                Metrics=['UnblendedCost'],
-                Filter=cost_filter
+                TimePeriod={"Start": start_date.strftime("%Y-%m-%d"), "End": end_date.strftime("%Y-%m-%d")},
+                Granularity="MONTHLY",
+                Metrics=["UnblendedCost"],
+                Filter=cost_filter,
             )
-            
-            if response['ResultsByTime'] and response['ResultsByTime'][0]['Total']['UnblendedCost']['Amount']:
-                total_cost = float(response['ResultsByTime'][0]['Total']['UnblendedCost']['Amount'])
+
+            if response["ResultsByTime"] and response["ResultsByTime"][0]["Total"]["UnblendedCost"]["Amount"]:
+                total_cost = float(response["ResultsByTime"][0]["Total"]["UnblendedCost"]["Amount"])
                 if total_cost > 0:
                     # Calculate per-unit cost based on usage
                     return self._calculate_unit_cost(total_cost, service, resource_type)
-            
+
             return 0.0  # No cost data found
-            
+
         except Exception as e:
             print(f"⚠️ Cost Explorer query failed: {e}")
             return 0.0
-    
+
     def _calculate_unit_cost(self, total_cost: float, service: str, resource_type: str) -> float:
         """Calculate per-unit cost from total cost and usage metrics."""
         # This would query CloudWatch for usage metrics and calculate unit cost
         # For now, returning calculated estimates based on typical usage patterns
         usage_multipliers = {
-            'EBS': {'gp3': 1000, 'gp2': 1200},  # Typical GB usage
-            'RDS': {'Snapshot': 5000},  # Typical snapshot GB
-            'VPC': {'NAT Gateway': 1}  # Per gateway
+            "EBS": {"gp3": 1000, "gp2": 1200},  # Typical GB usage
+            "RDS": {"Snapshot": 5000},  # Typical snapshot GB
+            "VPC": {"NAT Gateway": 1},  # Per gateway
         }
-        
+
         divisor = usage_multipliers.get(service, {}).get(resource_type, 1000)
         return total_cost / divisor
-    
+
     def _get_enterprise_fallback_pricing(self, resource_type: str, region: str, last_error: Exception = None) -> float:
         """Enterprise-compliant fallback pricing with graceful degradation."""
-        
+
         # Check for enterprise configuration override
         override_env = f"AWS_PRICING_OVERRIDE_{resource_type.upper()}_MONTHLY"
         override_value = os.getenv(override_env)
         if override_value:
             print(f"💼 Using enterprise pricing override: ${override_value}/month")
             return float(override_value)
-        
+
         # Check if running in compliance-mode or analysis can proceed with warnings
         compliance_mode = os.getenv("AWS_PRICING_STRICT_COMPLIANCE", "false").lower() == "true"
-        
+
         if compliance_mode:
             # Strict compliance: block operation
-            error_msg = f"ENTERPRISE VIOLATION: Cannot proceed without dynamic {resource_type} pricing. " \
-                       f"Last error: {last_error}. Set {override_env} or enable fallback pricing."
+            error_msg = (
+                f"ENTERPRISE VIOLATION: Cannot proceed without dynamic {resource_type} pricing. "
+                f"Last error: {last_error}. Set {override_env} or enable fallback pricing."
+            )
             print(f"🚫 {error_msg}")
             raise ValueError(error_msg)
         else:
             # Graceful degradation: allow analysis with standard AWS rates (documented approach)
             standard_rates = {
-                'nat_gateway': 32.40,  # AWS standard us-east-1 rate: $0.045/hour * 24 * 30
-                'transit_gateway': 36.00,  # AWS standard us-east-1 rate: $0.05/hour * 24 * 30  
-                'vpc_endpoint_interface': 7.20,  # AWS standard us-east-1 rate: $0.01/hour * 24 * 30
-                'elastic_ip_idle': 3.60,  # AWS standard us-east-1 rate: $0.005/hour * 24 * 30
+                "nat_gateway": 32.40,  # AWS standard us-east-1 rate: $0.045/hour * 24 * 30
+                "transit_gateway": 36.00,  # AWS standard us-east-1 rate: $0.05/hour * 24 * 30
+                "vpc_endpoint_interface": 7.20,  # AWS standard us-east-1 rate: $0.01/hour * 24 * 30
+                "elastic_ip_idle": 3.60,  # AWS standard us-east-1 rate: $0.005/hour * 24 * 30
             }
-            
+
             if resource_type in standard_rates:
                 fallback_cost = standard_rates[resource_type]
                 print(f"⚠️ FALLBACK PRICING: Using standard AWS rate ${fallback_cost}/month for {resource_type}")
                 print(f"   ℹ️  To fix: Check IAM permissions for pricing:GetProducts and ce:GetCostAndUsage")
                 print(f"   ℹ️  Or set {override_env} for enterprise override")
                 return fallback_cost
-            
-            # Last resort: query MCP servers for validation 
+
+            # Last resort: query MCP servers for validation
             return self._query_mcp_servers(resource_type, region, last_error)
-    
+
     @lru_cache(maxsize=128)
-    def get_vpc_endpoint_monthly_cost(self, region: str = 'us-east-1') -> float:
+    def get_vpc_endpoint_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get real-time VPC Endpoint monthly cost from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonVPC',
+                ServiceCode="AmazonVPC",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'VpcEndpoint'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(region)}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "VpcEndpoint"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'Hrs' in price_dimension.get('unit', ''):
-                            hourly_rate = float(price_dimension['pricePerUnit']['USD'])
+                    for price_dimension in term["priceDimensions"].values():
+                        if "Hrs" in price_dimension.get("unit", ""):
+                            hourly_rate = float(price_dimension["pricePerUnit"]["USD"])
                             monthly_cost = hourly_rate * 24 * 30  # Convert to monthly
                             return monthly_cost
-            
+
             # Fallback to Cost Explorer
-            return self._get_from_cost_explorer('VPC', 'VpcEndpoint', region)
-            
+            return self._get_from_cost_explorer("VPC", "VpcEndpoint", region)
+
         except Exception as e:
-            return self._get_from_cost_explorer('VPC', 'VpcEndpoint', region)
+            return self._get_from_cost_explorer("VPC", "VpcEndpoint", region)
 
     @lru_cache(maxsize=128)
-    def get_transit_gateway_monthly_cost(self, region: str = 'us-east-1') -> float:
+    def get_transit_gateway_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get real-time Transit Gateway monthly cost from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonVPC',
+                ServiceCode="AmazonVPC",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'Transit Gateway'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(region)}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Transit Gateway"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'Hrs' in price_dimension.get('unit', ''):
-                            hourly_rate = float(price_dimension['pricePerUnit']['USD'])
+                    for price_dimension in term["priceDimensions"].values():
+                        if "Hrs" in price_dimension.get("unit", ""):
+                            hourly_rate = float(price_dimension["pricePerUnit"]["USD"])
                             monthly_cost = hourly_rate * 24 * 30  # Convert to monthly
                             return monthly_cost
-            
+
             # Fallback to Cost Explorer
-            return self._get_from_cost_explorer('VPC', 'Transit Gateway', region)
-            
+            return self._get_from_cost_explorer("VPC", "Transit Gateway", region)
+
         except Exception as e:
-            return self._get_from_cost_explorer('VPC', 'Transit Gateway', region)
+            return self._get_from_cost_explorer("VPC", "Transit Gateway", region)
 
     @lru_cache(maxsize=128)
-    def get_elastic_ip_monthly_cost(self, region: str = 'us-east-1') -> float:
+    def get_elastic_ip_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get real-time Elastic IP monthly cost from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonEC2',
+                ServiceCode="AmazonEC2",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'IP Address'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': self._get_region_name(region)}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "IP Address"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": self._get_region_name(region)},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'Hrs' in price_dimension.get('unit', ''):
-                            hourly_rate = float(price_dimension['pricePerUnit']['USD'])
+                    for price_dimension in term["priceDimensions"].values():
+                        if "Hrs" in price_dimension.get("unit", ""):
+                            hourly_rate = float(price_dimension["pricePerUnit"]["USD"])
                             monthly_cost = hourly_rate * 24 * 30  # Convert to monthly
                             return monthly_cost
-            
+
             # Fallback to Cost Explorer
-            return self._get_from_cost_explorer('EC2', 'Elastic IP', region)
-            
+            return self._get_from_cost_explorer("EC2", "Elastic IP", region)
+
         except Exception as e:
-            return self._get_from_cost_explorer('EC2', 'Elastic IP', region)
+            return self._get_from_cost_explorer("EC2", "Elastic IP", region)
 
     @lru_cache(maxsize=128)
-    def get_data_transfer_monthly_cost(self, region: str = 'us-east-1') -> float:
+    def get_data_transfer_monthly_cost(self, region: str = "us-east-1") -> float:
         """Get real-time Data Transfer cost per GB from AWS Pricing API."""
         try:
             response = self.pricing_client.get_products(
-                ServiceCode='AmazonEC2',
+                ServiceCode="AmazonEC2",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'Data Transfer'},
-                    {'Type': 'TERM_MATCH', 'Field': 'fromLocation', 'Value': self._get_region_name(region)},
-                    {'Type': 'TERM_MATCH', 'Field': 'toLocation', 'Value': 'External'}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Data Transfer"},
+                    {"Type": "TERM_MATCH", "Field": "fromLocation", "Value": self._get_region_name(region)},
+                    {"Type": "TERM_MATCH", "Field": "toLocation", "Value": "External"},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if response['PriceList']:
-                price_data = json.loads(response['PriceList'][0])
-                on_demand = price_data['terms']['OnDemand']
+
+            if response["PriceList"]:
+                price_data = json.loads(response["PriceList"][0])
+                on_demand = price_data["terms"]["OnDemand"]
                 for term in on_demand.values():
-                    for price_dimension in term['priceDimensions'].values():
-                        if 'GB' in price_dimension.get('unit', ''):
-                            return float(price_dimension['pricePerUnit']['USD'])
-            
+                    for price_dimension in term["priceDimensions"].values():
+                        if "GB" in price_dimension.get("unit", ""):
+                            return float(price_dimension["pricePerUnit"]["USD"])
+
             # Fallback to Cost Explorer
-            return self._get_from_cost_explorer('EC2', 'Data Transfer', region)
-            
+            return self._get_from_cost_explorer("EC2", "Data Transfer", region)
+
         except Exception as e:
-            return self._get_from_cost_explorer('EC2', 'Data Transfer', region)
+            return self._get_from_cost_explorer("EC2", "Data Transfer", region)
 
     def _query_mcp_servers(self, resource_type: str, region: str, last_error: Exception = None) -> float:
         """Query MCP servers for cost validation as final fallback."""
@@ -407,31 +401,36 @@ class AWSPricingAPI:
 💡 TIP: Run 'aws pricing get-products --service-code AmazonVPC' to test permissions
 """
             print(guidance_msg)
-            
+
             # ENTERPRISE COMPLIANCE: Do not return hardcoded fallback
-            raise ValueError(f"Unable to get pricing for {resource_type} in {region}. Check IAM permissions and MCP server connectivity.")
-            
+            raise ValueError(
+                f"Unable to get pricing for {resource_type} in {region}. Check IAM permissions and MCP server connectivity."
+            )
+
         except Exception as mcp_error:
             print(f"🚫 Final fallback failed: {mcp_error}")
-            raise ValueError(f"Unable to get pricing for {resource_type} in {region}. Check IAM permissions and MCP server connectivity.")
-    
+            raise ValueError(
+                f"Unable to get pricing for {resource_type} in {region}. Check IAM permissions and MCP server connectivity."
+            )
+
     def _get_region_name(self, region_code: str) -> str:
         """Convert region code to full region name for Pricing API."""
         region_map = {
-            'us-east-1': 'US East (N. Virginia)',
-            'us-west-1': 'US West (N. California)',
-            'us-west-2': 'US West (Oregon)',
-            'eu-west-1': 'EU (Ireland)',
-            'eu-west-2': 'EU (London)',
-            'eu-central-1': 'EU (Frankfurt)',
-            'ap-southeast-1': 'Asia Pacific (Singapore)',
-            'ap-southeast-2': 'Asia Pacific (Sydney)',
-            'ap-northeast-1': 'Asia Pacific (Tokyo)',
-            'ap-south-1': 'Asia Pacific (Mumbai)',
-            'ca-central-1': 'Canada (Central)',
-            'sa-east-1': 'South America (São Paulo)',
+            "us-east-1": "US East (N. Virginia)",
+            "us-west-1": "US West (N. California)",
+            "us-west-2": "US West (Oregon)",
+            "eu-west-1": "EU (Ireland)",
+            "eu-west-2": "EU (London)",
+            "eu-central-1": "EU (Frankfurt)",
+            "ap-southeast-1": "Asia Pacific (Singapore)",
+            "ap-southeast-2": "Asia Pacific (Sydney)",
+            "ap-northeast-1": "Asia Pacific (Tokyo)",
+            "ap-south-1": "Asia Pacific (Mumbai)",
+            "ca-central-1": "Canada (Central)",
+            "sa-east-1": "South America (São Paulo)",
         }
-        return region_map.get(region_code, 'US East (N. Virginia)')
+        return region_map.get(region_code, "US East (N. Virginia)")
+
 
 # Global instance for easy import
-pricing_api = AWSPricingAPI()
+pricing_api = AWSPricingAPI()