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

runbooks/finops/rds_snapshot_optimizer.py

@@ -16,23 +16,31 @@ IMPROVEMENTS:
 - Support for MANAGEMENT_PROFILE testing
 """
 
-import logging
+import asyncio
 import json
+import logging
+import os
 import time
-import asyncio
 from datetime import datetime, timedelta, timezone
-from typing import Dict, List, Optional, Tuple, Any
-import os
+from typing import Any, Dict, List, Optional, Tuple
 
-import click
 import boto3
+import click
 from botocore.exceptions import ClientError
 
+from ..common.profile_utils import get_profile_for_operation
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel
+    console,
+    create_panel,
+    create_progress_bar,
+    create_table,
+    format_cost,
+    print_error,
+    print_header,
+    print_info,
+    print_success,
+    print_warning,
 )
-from ..common.profile_utils import get_profile_for_operation
 
 logger = logging.getLogger(__name__)
 
@@ -59,12 +67,12 @@ class EnhancedRDSSnapshotOptimizer:
 
         # Discovery metrics
         self.discovery_stats = {
-            'total_discovered': 0,
-            'manual_snapshots': 0,
-            'automated_snapshots': 0,
-            'accounts_covered': set(),
-            'total_storage_gb': 0,
-            'estimated_monthly_cost': 0.0
+            "total_discovered": 0,
+            "manual_snapshots": 0,
+            "automated_snapshots": 0,
+            "accounts_covered": set(),
+            "total_storage_gb": 0,
+            "estimated_monthly_cost": 0.0,
         }
 
         # PHASE 2 FIX: Dynamic pricing instead of static values
@@ -79,7 +87,7 @@ class EnhancedRDSSnapshotOptimizer:
             self.session = boto3.Session(profile_name=resolved_profile)
 
             # Verify access
-            sts_client = self.session.client('sts')
+            sts_client = self.session.client("sts")
             identity = sts_client.get_caller_identity()
 
             print_success(f"✅ Session initialized: {resolved_profile} (Account: {identity['Account']})")
@@ -105,40 +113,33 @@ class EnhancedRDSSnapshotOptimizer:
                     return cached_price
 
             # Query AWS Pricing API
-            pricing_client = self.session.client('pricing', region_name='us-east-1')
+            pricing_client = self.session.client("pricing", region_name="us-east-1")
 
             response = pricing_client.get_products(
-                ServiceCode='AmazonRDS',
+                ServiceCode="AmazonRDS",
                 Filters=[
-                    {
-                        'Type': 'TERM_MATCH',
-                        'Field': 'productFamily',
-                        'Value': 'Database Storage'
-                    },
-                    {
-                        'Type': 'TERM_MATCH',
-                        'Field': 'usageType',
-                        'Value': 'SnapshotUsage:db.gp2'
-                    }
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Database Storage"},
+                    {"Type": "TERM_MATCH", "Field": "usageType", "Value": "SnapshotUsage:db.gp2"},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
 
-            if response.get('PriceList'):
+            if response.get("PriceList"):
                 import json
-                price_item = json.loads(response['PriceList'][0])
+
+                price_item = json.loads(response["PriceList"][0])
 
                 # Extract pricing from AWS pricing structure
-                terms = price_item.get('terms', {})
-                on_demand = terms.get('OnDemand', {})
+                terms = price_item.get("terms", {})
+                on_demand = terms.get("OnDemand", {})
 
                 for term_key, term_value in on_demand.items():
-                    price_dimensions = term_value.get('priceDimensions', {})
+                    price_dimensions = term_value.get("priceDimensions", {})
                     for dimension_key, dimension_value in price_dimensions.items():
-                        price_per_unit = dimension_value.get('pricePerUnit', {})
-                        usd_price = price_per_unit.get('USD', '0')
+                        price_per_unit = dimension_value.get("pricePerUnit", {})
+                        usd_price = price_per_unit.get("USD", "0")
 
-                        if usd_price and usd_price != '0':
+                        if usd_price and usd_price != "0":
                             dynamic_price = float(usd_price)
 
                             # Cache the result
@@ -156,7 +157,9 @@ class EnhancedRDSSnapshotOptimizer:
             print_warning(f"Pricing API error: {str(e)[:50]}... Using fallback")
             return 0.095
 
-    def discover_snapshots_via_config_aggregator(self, target_account_id: str = None, manual_only: bool = False) -> List[Dict]:
+    def discover_snapshots_via_config_aggregator(
+        self, target_account_id: str = None, manual_only: bool = False
+    ) -> List[Dict]:
         """
         Discover RDS snapshots using AWS Config aggregator with direct RDS API fallback
 
@@ -196,7 +199,7 @@ class EnhancedRDSSnapshotOptimizer:
 
                         if processed_snapshot:
                             # Apply manual filter if requested
-                            if manual_only and processed_snapshot.get('SnapshotType') != 'manual':
+                            if manual_only and processed_snapshot.get("SnapshotType") != "manual":
                                 continue  # Skip automated snapshots when manual_only=True
 
                             discovered_snapshots.append(processed_snapshot)
@@ -224,7 +227,9 @@ class EnhancedRDSSnapshotOptimizer:
             if "NoSuchConfigurationAggregatorException" in str(e):
                 print_warning("🏢 Organization Config aggregator not accessible from this account")
                 print_info("💡 For organization-wide analysis: Use MANAGEMENT_PROFILE")
-                print_info("💡 For single-account analysis: This account may not have RDS snapshots or Config aggregator access")
+                print_info(
+                    "💡 For single-account analysis: This account may not have RDS snapshots or Config aggregator access"
+                )
                 print_info("🔍 Alternative: Check AWS Console → RDS → Snapshots for manual verification")
             else:
                 print_warning("Ensure MANAGEMENT_PROFILE has Config aggregator access")
@@ -243,8 +248,14 @@ class EnhancedRDSSnapshotOptimizer:
         """
         try:
             expected_test_accounts = {
-                '91893567291', '142964829704', '363435891329', '507583929055',
-                '614294421455', '695366013198', '761860562159', '802669565615'
+                "91893567291",
+                "142964829704",
+                "363435891329",
+                "507583929055",
+                "614294421455",
+                "695366013198",
+                "761860562159",
+                "802669565615",
             }
             expected_total_snapshots = 71
 
@@ -253,8 +264,8 @@ class EnhancedRDSSnapshotOptimizer:
             account_breakdown = {}
 
             for snapshot in discovered_snapshots:
-                account_id = snapshot.get('AccountId', 'unknown')
-                if account_id != 'unknown':
+                account_id = snapshot.get("AccountId", "unknown")
+                if account_id != "unknown":
                     discovered_accounts.add(account_id)
                     if account_id not in account_breakdown:
                         account_breakdown[account_id] = 0
@@ -275,30 +286,36 @@ class EnhancedRDSSnapshotOptimizer:
                     {"header": "📊 Metric", "style": "cyan bold"},
                     {"header": "🔢 Expected", "style": "green bold"},
                     {"header": "🔢 Discovered", "style": "blue bold"},
-                    {"header": "📈 Status", "style": "yellow bold"}
-                ]
+                    {"header": "📈 Status", "style": "yellow bold"},
+                ],
             )
 
             # Total snapshots validation
-            snapshot_coverage = (total_discovered / expected_total_snapshots) * 100 if expected_total_snapshots > 0 else 0
-            snapshot_status = "✅ Good" if snapshot_coverage >= 80 else "⚠️ Gap" if snapshot_coverage >= 60 else "❌ Poor"
+            snapshot_coverage = (
+                (total_discovered / expected_total_snapshots) * 100 if expected_total_snapshots > 0 else 0
+            )
+            snapshot_status = (
+                "✅ Good" if snapshot_coverage >= 80 else "⚠️ Gap" if snapshot_coverage >= 60 else "❌ Poor"
+            )
 
             validation_table.add_row(
                 "Total Snapshots",
                 str(expected_total_snapshots),
                 str(total_discovered),
-                f"{snapshot_status} ({snapshot_coverage:.1f}%)"
+                f"{snapshot_status} ({snapshot_coverage:.1f}%)",
             )
 
             # Account coverage validation
             account_coverage = (len(test_accounts_found) / len(expected_test_accounts)) * 100
-            account_status = "✅ Complete" if account_coverage == 100 else f"⚠️ Partial ({len(missing_test_accounts)} missing)"
+            account_status = (
+                "✅ Complete" if account_coverage == 100 else f"⚠️ Partial ({len(missing_test_accounts)} missing)"
+            )
 
             validation_table.add_row(
                 "Test Accounts",
                 str(len(expected_test_accounts)),
                 str(len(test_accounts_found)),
-                f"{account_status} ({account_coverage:.1f}%)"
+                f"{account_status} ({account_coverage:.1f}%)",
             )
 
             console.print(validation_table)
@@ -318,7 +335,9 @@ class EnhancedRDSSnapshotOptimizer:
                 print_info("   • Consider direct RDS API calls for gap analysis")
 
             elif total_discovered >= expected_total_snapshots:
-                print_success(f"✅ Discovery Success: Found {total_discovered} snapshots (≥{expected_total_snapshots} expected)")
+                print_success(
+                    f"✅ Discovery Success: Found {total_discovered} snapshots (≥{expected_total_snapshots} expected)"
+                )
 
                 if target_account_id and target_account_id in account_breakdown:
                     target_count = account_breakdown[target_account_id]
@@ -336,16 +355,16 @@ class EnhancedRDSSnapshotOptimizer:
         try:
             # Extract base metadata
             snapshot_info = {
-                'DBSnapshotIdentifier': config_data.get('resourceId', 'unknown'),
-                'AccountId': config_data.get('accountId', 'unknown'),
-                'Region': config_data.get('awsRegion', 'unknown'),
-                'DiscoveryMethod': 'config_aggregator',
-                'ConfigCaptureTime': config_data.get('configurationItemCaptureTime'),
-                'ResourceCreationTime': config_data.get('resourceCreationTime')
+                "DBSnapshotIdentifier": config_data.get("resourceId", "unknown"),
+                "AccountId": config_data.get("accountId", "unknown"),
+                "Region": config_data.get("awsRegion", "unknown"),
+                "DiscoveryMethod": "config_aggregator",
+                "ConfigCaptureTime": config_data.get("configurationItemCaptureTime"),
+                "ResourceCreationTime": config_data.get("resourceCreationTime"),
             }
 
             # Parse configuration details
-            configuration = config_data.get('configuration', {})
+            configuration = config_data.get("configuration", {})
             if isinstance(configuration, str):
                 try:
                     configuration = json.loads(configuration)
@@ -362,99 +381,61 @@ class EnhancedRDSSnapshotOptimizer:
                             return configuration[field_name]
                     return default
 
-                snapshot_info.update({
-                    # Core identifiers with variations
-                    'DBInstanceIdentifier': safe_extract([
-                        'dBInstanceIdentifier', 'dbInstanceIdentifier', 'DBInstanceIdentifier'
-                    ], 'unknown'),
-
-                    'SnapshotType': safe_extract([
-                        'snapshotType', 'SnapshotType', 'type'
-                    ], 'unknown'),
-
-                    'Status': safe_extract([
-                        'status', 'Status', 'snapshotStatus'
-                    ], 'unknown'),
-
-                    'Engine': safe_extract([
-                        'engine', 'Engine', 'engineType'
-                    ], 'unknown'),
-
-                    'EngineVersion': safe_extract([
-                        'engineVersion', 'EngineVersion'
-                    ], 'unknown'),
-
-                    # Storage details with type coercion
-                    'AllocatedStorage': int(safe_extract([
-                        'allocatedStorage', 'AllocatedStorage', 'storageSize'
-                    ], 0) or 0),
-
-                    'StorageType': safe_extract([
-                        'storageType', 'StorageType'
-                    ], 'gp2'),
-
-                    'Encrypted': bool(safe_extract([
-                        'encrypted', 'Encrypted', 'storageEncrypted'
-                    ], False)),
-
-                    # Timestamps with variations
-                    'SnapshotCreateTime': safe_extract([
-                        'snapshotCreateTime', 'SnapshotCreateTime', 'createTime'
-                    ]),
-
-                    'InstanceCreateTime': safe_extract([
-                        'instanceCreateTime', 'InstanceCreateTime'
-                    ]),
-
-                    # Network and location
-                    'VpcId': safe_extract([
-                        'vpcId', 'VpcId', 'vpc'
-                    ]),
-
-                    'AvailabilityZone': safe_extract([
-                        'availabilityZone', 'AvailabilityZone', 'az'
-                    ]),
-
-                    # Licensing and security
-                    'LicenseModel': safe_extract([
-                        'licenseModel', 'LicenseModel'
-                    ], 'unknown'),
-
-                    'KmsKeyId': safe_extract([
-                        'kmsKeyId', 'KmsKeyId', 'kmsKey'
-                    ]),
-
-                    'IAMDatabaseAuthenticationEnabled': bool(safe_extract([
-                        'iAMDatabaseAuthenticationEnabled', 'IAMDatabaseAuthenticationEnabled'
-                    ], False)),
-
-                    # Tags with enhanced processing
-                    'TagList': safe_extract([
-                        'tagList', 'TagList', 'tags', 'Tags'
-                    ], [])
-                })
+                snapshot_info.update(
+                    {
+                        # Core identifiers with variations
+                        "DBInstanceIdentifier": safe_extract(
+                            ["dBInstanceIdentifier", "dbInstanceIdentifier", "DBInstanceIdentifier"], "unknown"
+                        ),
+                        "SnapshotType": safe_extract(["snapshotType", "SnapshotType", "type"], "unknown"),
+                        "Status": safe_extract(["status", "Status", "snapshotStatus"], "unknown"),
+                        "Engine": safe_extract(["engine", "Engine", "engineType"], "unknown"),
+                        "EngineVersion": safe_extract(["engineVersion", "EngineVersion"], "unknown"),
+                        # Storage details with type coercion
+                        "AllocatedStorage": int(
+                            safe_extract(["allocatedStorage", "AllocatedStorage", "storageSize"], 0) or 0
+                        ),
+                        "StorageType": safe_extract(["storageType", "StorageType"], "gp2"),
+                        "Encrypted": bool(safe_extract(["encrypted", "Encrypted", "storageEncrypted"], False)),
+                        # Timestamps with variations
+                        "SnapshotCreateTime": safe_extract(["snapshotCreateTime", "SnapshotCreateTime", "createTime"]),
+                        "InstanceCreateTime": safe_extract(["instanceCreateTime", "InstanceCreateTime"]),
+                        # Network and location
+                        "VpcId": safe_extract(["vpcId", "VpcId", "vpc"]),
+                        "AvailabilityZone": safe_extract(["availabilityZone", "AvailabilityZone", "az"]),
+                        # Licensing and security
+                        "LicenseModel": safe_extract(["licenseModel", "LicenseModel"], "unknown"),
+                        "KmsKeyId": safe_extract(["kmsKeyId", "KmsKeyId", "kmsKey"]),
+                        "IAMDatabaseAuthenticationEnabled": bool(
+                            safe_extract(
+                                ["iAMDatabaseAuthenticationEnabled", "IAMDatabaseAuthenticationEnabled"], False
+                            )
+                        ),
+                        # Tags with enhanced processing
+                        "TagList": safe_extract(["tagList", "TagList", "tags", "Tags"], []),
+                    }
+                )
 
             # Calculate age and cost estimates
-            snapshot_create_time = snapshot_info.get('SnapshotCreateTime')
+            snapshot_create_time = snapshot_info.get("SnapshotCreateTime")
             if snapshot_create_time:
                 try:
                     if isinstance(snapshot_create_time, str):
-                        create_time = datetime.fromisoformat(
-                            snapshot_create_time.replace('Z', '+00:00')
-                        )
+                        create_time = datetime.fromisoformat(snapshot_create_time.replace("Z", "+00:00"))
                     else:
                         create_time = snapshot_create_time
 
                     age_days = (datetime.now(timezone.utc) - create_time).days
-                    snapshot_info['AgeDays'] = age_days
+                    snapshot_info["AgeDays"] = age_days
 
                     # PHASE 2 FIX: Calculate storage cost using dynamic pricing
-                    allocated_storage = snapshot_info.get('AllocatedStorage', 0)
+                    allocated_storage = snapshot_info.get("AllocatedStorage", 0)
                     if allocated_storage > 0:
                         # Get dynamic pricing if not already cached
                         if self.snapshot_cost_per_gb_month is None:
                             try:
                                 import asyncio
+
                                 loop = asyncio.new_event_loop()
                                 asyncio.set_event_loop(loop)
                                 self.snapshot_cost_per_gb_month = loop.run_until_complete(
@@ -466,17 +447,17 @@ class EnhancedRDSSnapshotOptimizer:
                                 self.snapshot_cost_per_gb_month = 0.095
 
                         monthly_cost = allocated_storage * self.snapshot_cost_per_gb_month
-                        snapshot_info['EstimatedMonthlyCost'] = round(monthly_cost, 2)
-                        snapshot_info['EstimatedAnnualCost'] = round(monthly_cost * 12, 2)
+                        snapshot_info["EstimatedMonthlyCost"] = round(monthly_cost, 2)
+                        snapshot_info["EstimatedAnnualCost"] = round(monthly_cost * 12, 2)
                     else:
-                        snapshot_info['EstimatedMonthlyCost'] = 0.0
-                        snapshot_info['EstimatedAnnualCost'] = 0.0
+                        snapshot_info["EstimatedMonthlyCost"] = 0.0
+                        snapshot_info["EstimatedAnnualCost"] = 0.0
 
                 except Exception as e:
                     logger.debug(f"Failed to calculate snapshot age/cost: {e}")
-                    snapshot_info['AgeDays'] = 0
-                    snapshot_info['EstimatedMonthlyCost'] = 0.0
-                    snapshot_info['EstimatedAnnualCost'] = 0.0
+                    snapshot_info["AgeDays"] = 0
+                    snapshot_info["EstimatedMonthlyCost"] = 0.0
+                    snapshot_info["EstimatedAnnualCost"] = 0.0
 
             return snapshot_info
 
@@ -486,23 +467,23 @@ class EnhancedRDSSnapshotOptimizer:
 
     def _update_discovery_stats(self, snapshot: Dict) -> None:
         """Update discovery statistics with processed snapshot"""
-        self.discovery_stats['total_discovered'] += 1
+        self.discovery_stats["total_discovered"] += 1
 
-        snapshot_type = snapshot.get('SnapshotType', '').lower()
-        if snapshot_type == 'manual':
-            self.discovery_stats['manual_snapshots'] += 1
-        elif snapshot_type == 'automated':
-            self.discovery_stats['automated_snapshots'] += 1
+        snapshot_type = snapshot.get("SnapshotType", "").lower()
+        if snapshot_type == "manual":
+            self.discovery_stats["manual_snapshots"] += 1
+        elif snapshot_type == "automated":
+            self.discovery_stats["automated_snapshots"] += 1
 
-        account_id = snapshot.get('AccountId', 'unknown')
-        if account_id != 'unknown':
-            self.discovery_stats['accounts_covered'].add(account_id)
+        account_id = snapshot.get("AccountId", "unknown")
+        if account_id != "unknown":
+            self.discovery_stats["accounts_covered"].add(account_id)
 
-        allocated_storage = snapshot.get('AllocatedStorage', 0)
-        self.discovery_stats['total_storage_gb'] += allocated_storage
+        allocated_storage = snapshot.get("AllocatedStorage", 0)
+        self.discovery_stats["total_storage_gb"] += allocated_storage
 
-        monthly_cost = snapshot.get('EstimatedMonthlyCost', 0.0)
-        self.discovery_stats['estimated_monthly_cost'] += monthly_cost
+        monthly_cost = snapshot.get("EstimatedMonthlyCost", 0.0)
+        self.discovery_stats["estimated_monthly_cost"] += monthly_cost
 
     def _display_discovery_summary(self) -> None:
         """Display enhanced discovery summary"""
@@ -515,39 +496,23 @@ class EnhancedRDSSnapshotOptimizer:
             columns=[
                 {"header": "📊 Metric", "style": "cyan bold"},
                 {"header": "🔢 Count", "style": "green bold"},
-                {"header": "ℹ️ Details", "style": "blue"}
-            ]
+                {"header": "ℹ️ Details", "style": "blue"},
+            ],
         )
 
-        discovery_table.add_row(
-            "Total Snapshots Discovered",
-            str(stats['total_discovered']),
-            "All snapshot types"
-        )
-        discovery_table.add_row(
-            "Manual Snapshots",
-            str(stats['manual_snapshots']),
-            "Cleanup candidates"
-        )
-        discovery_table.add_row(
-            "Automated Snapshots",
-            str(stats['automated_snapshots']),
-            "Retention policy managed"
-        )
+        discovery_table.add_row("Total Snapshots Discovered", str(stats["total_discovered"]), "All snapshot types")
+        discovery_table.add_row("Manual Snapshots", str(stats["manual_snapshots"]), "Cleanup candidates")
+        discovery_table.add_row("Automated Snapshots", str(stats["automated_snapshots"]), "Retention policy managed")
         discovery_table.add_row(
             "Accounts Covered",
-            str(len(stats['accounts_covered'])),
-            f"Account IDs: {', '.join(sorted(stats['accounts_covered']))}"
+            str(len(stats["accounts_covered"])),
+            f"Account IDs: {', '.join(sorted(stats['accounts_covered']))}",
         )
         discovery_table.add_row(
-            "Total Storage",
-            f"{stats['total_storage_gb']:,} GB",
-            f"${stats['estimated_monthly_cost']:,.2f}/month"
+            "Total Storage", f"{stats['total_storage_gb']:,} GB", f"${stats['estimated_monthly_cost']:,.2f}/month"
         )
         discovery_table.add_row(
-            "Estimated Annual Cost",
-            format_cost(stats['estimated_monthly_cost'] * 12),
-            "Current snapshot storage cost"
+            "Estimated Annual Cost", format_cost(stats["estimated_monthly_cost"] * 12), "Current snapshot storage cost"
         )
 
         console.print(discovery_table)
@@ -567,95 +532,80 @@ class EnhancedRDSSnapshotOptimizer:
         print_header(f"Enhanced RDS Snapshot Optimization Analysis")
 
         # Categorize snapshots by type and age
-        manual_snapshots = [s for s in snapshots if s.get('SnapshotType', '').lower() == 'manual']
-        automated_snapshots = [s for s in snapshots if s.get('SnapshotType', '').lower() == 'automated']
+        manual_snapshots = [s for s in snapshots if s.get("SnapshotType", "").lower() == "manual"]
+        automated_snapshots = [s for s in snapshots if s.get("SnapshotType", "").lower() == "automated"]
 
         # ENHANCED OPTIMIZATION LOGIC: Multiple optimization categories
         optimization_categories = []
 
         # Category 1: Old manual snapshots (conservative cleanup)
-        old_manual_snapshots = [
-            s for s in manual_snapshots
-            if s.get('AgeDays', 0) >= age_threshold
-        ]
+        old_manual_snapshots = [s for s in manual_snapshots if s.get("AgeDays", 0) >= age_threshold]
 
         # Category 2: Very old automated snapshots (>365 days - potential retention review)
-        very_old_automated = [
-            s for s in automated_snapshots
-            if s.get('AgeDays', 0) >= 365
-        ]
+        very_old_automated = [s for s in automated_snapshots if s.get("AgeDays", 0) >= 365]
 
         # Category 3: Automated snapshots >180 days (retention policy review)
         old_automated_review = [
-            s for s in automated_snapshots
-            if s.get('AgeDays', 0) >= 180 and s.get('AgeDays', 0) < 365
+            s for s in automated_snapshots if s.get("AgeDays", 0) >= 180 and s.get("AgeDays", 0) < 365
         ]
 
         # Category 4: All snapshots >90 days (comprehensive review scenario)
-        all_old_snapshots = [
-            s for s in snapshots
-            if s.get('AgeDays', 0) >= age_threshold
-        ]
+        all_old_snapshots = [s for s in snapshots if s.get("AgeDays", 0) >= age_threshold]
 
         # Calculate savings for different optimization scenarios
         scenarios = {
-            'conservative_manual': {
-                'snapshots': old_manual_snapshots,
-                'description': f'Manual snapshots >{age_threshold} days (safe cleanup)',
-                'risk_level': 'Low'
+            "conservative_manual": {
+                "snapshots": old_manual_snapshots,
+                "description": f"Manual snapshots >{age_threshold} days (safe cleanup)",
+                "risk_level": "Low",
             },
-            'automated_review': {
-                'snapshots': very_old_automated,
-                'description': 'Automated snapshots >365 days (retention review)',
-                'risk_level': 'Medium'
+            "automated_review": {
+                "snapshots": very_old_automated,
+                "description": "Automated snapshots >365 days (retention review)",
+                "risk_level": "Medium",
             },
-            'comprehensive': {
-                'snapshots': all_old_snapshots,
-                'description': f'All snapshots >{age_threshold} days (comprehensive review)',
-                'risk_level': 'Medium-High'
+            "comprehensive": {
+                "snapshots": all_old_snapshots,
+                "description": f"All snapshots >{age_threshold} days (comprehensive review)",
+                "risk_level": "Medium-High",
+            },
+            "retention_optimization": {
+                "snapshots": old_automated_review,
+                "description": "Automated snapshots 180-365 days (policy optimization)",
+                "risk_level": "Low-Medium",
             },
-            'retention_optimization': {
-                'snapshots': old_automated_review,
-                'description': 'Automated snapshots 180-365 days (policy optimization)',
-                'risk_level': 'Low-Medium'
-            }
         }
 
         # Calculate savings for each scenario
         optimization_results = {}
         for scenario_name, scenario_data in scenarios.items():
-            snapshots_list = scenario_data['snapshots']
-            storage_gb = sum(s.get('AllocatedStorage', 0) for s in snapshots_list)
-            monthly_cost = sum(s.get('EstimatedMonthlyCost', 0) for s in snapshots_list)
+            snapshots_list = scenario_data["snapshots"]
+            storage_gb = sum(s.get("AllocatedStorage", 0) for s in snapshots_list)
+            monthly_cost = sum(s.get("EstimatedMonthlyCost", 0) for s in snapshots_list)
             annual_savings = monthly_cost * 12
 
             optimization_results[scenario_name] = {
-                'count': len(snapshots_list),
-                'storage_gb': storage_gb,
-                'monthly_cost': monthly_cost,
-                'annual_savings': annual_savings,
-                'description': scenario_data['description'],
-                'risk_level': scenario_data['risk_level'],
-                'snapshots': snapshots_list
+                "count": len(snapshots_list),
+                "storage_gb": storage_gb,
+                "monthly_cost": monthly_cost,
+                "annual_savings": annual_savings,
+                "description": scenario_data["description"],
+                "risk_level": scenario_data["risk_level"],
+                "snapshots": snapshots_list,
             }
 
         # Account breakdown for the most realistic scenario (comprehensive review)
-        primary_scenario = optimization_results['comprehensive']
+        primary_scenario = optimization_results["comprehensive"]
         account_breakdown = {}
-        for snapshot in primary_scenario['snapshots']:
-            account_id = snapshot.get('AccountId', 'unknown')
+        for snapshot in primary_scenario["snapshots"]:
+            account_id = snapshot.get("AccountId", "unknown")
             if account_id not in account_breakdown:
-                account_breakdown[account_id] = {
-                    'count': 0,
-                    'storage_gb': 0,
-                    'monthly_cost': 0.0,
-                    'snapshots': []
-                }
-
-            account_breakdown[account_id]['count'] += 1
-            account_breakdown[account_id]['storage_gb'] += snapshot.get('AllocatedStorage', 0)
-            account_breakdown[account_id]['monthly_cost'] += snapshot.get('EstimatedMonthlyCost', 0.0)
-            account_breakdown[account_id]['snapshots'].append(snapshot.get('DBSnapshotIdentifier', 'unknown'))
+                account_breakdown[account_id] = {"count": 0, "storage_gb": 0, "monthly_cost": 0.0, "snapshots": []}
+
+            account_breakdown[account_id]["count"] += 1
+            account_breakdown[account_id]["storage_gb"] += snapshot.get("AllocatedStorage", 0)
+            account_breakdown[account_id]["monthly_cost"] += snapshot.get("EstimatedMonthlyCost", 0.0)
+            account_breakdown[account_id]["snapshots"].append(snapshot.get("DBSnapshotIdentifier", "unknown"))
 
         # Display comprehensive optimization results
         optimization_table = create_table(
@@ -666,8 +616,8 @@ class EnhancedRDSSnapshotOptimizer:
                 {"header": "📊 Snapshots", "style": "green bold"},
                 {"header": "💾 Storage (GB)", "style": "yellow bold"},
                 {"header": "💵 Annual Savings", "style": "red bold"},
-                {"header": "⚠️ Risk Level", "style": "blue bold"}
-            ]
+                {"header": "⚠️ Risk Level", "style": "blue bold"},
+            ],
         )
 
         # Current state (baseline)
@@ -675,37 +625,37 @@ class EnhancedRDSSnapshotOptimizer:
             "📊 Current State (All Snapshots)",
             str(len(snapshots)),
             f"{sum(s.get('AllocatedStorage', 0) for s in snapshots):,}",
-            format_cost(sum(s.get('EstimatedMonthlyCost', 0) for s in snapshots) * 12),
-            "Baseline"
+            format_cost(sum(s.get("EstimatedMonthlyCost", 0) for s in snapshots) * 12),
+            "Baseline",
         )
 
         # Display all optimization scenarios
-        scenario_priorities = ['conservative_manual', 'retention_optimization', 'automated_review', 'comprehensive']
+        scenario_priorities = ["conservative_manual", "retention_optimization", "automated_review", "comprehensive"]
         scenario_icons = {
-            'conservative_manual': '🟢',
-            'retention_optimization': '🟡',
-            'automated_review': '🟠',
-            'comprehensive': '🔴'
+            "conservative_manual": "🟢",
+            "retention_optimization": "🟡",
+            "automated_review": "🟠",
+            "comprehensive": "🔴",
         }
 
         for scenario_name in scenario_priorities:
             if scenario_name in optimization_results:
                 scenario = optimization_results[scenario_name]
-                icon = scenario_icons.get(scenario_name, '📋')
+                icon = scenario_icons.get(scenario_name, "📋")
 
                 optimization_table.add_row(
                     f"{icon} {scenario['description']}",
-                    str(scenario['count']),
+                    str(scenario["count"]),
                     f"{scenario['storage_gb']:,}",
-                    format_cost(scenario['annual_savings']),
-                    scenario['risk_level']
+                    format_cost(scenario["annual_savings"]),
+                    scenario["risk_level"],
                 )
 
         console.print(optimization_table)
 
         # Recommended scenario analysis
-        recommended_scenario = optimization_results['comprehensive']  # Most realistic
-        if recommended_scenario['annual_savings'] > 0:
+        recommended_scenario = optimization_results["comprehensive"]  # Most realistic
+        if recommended_scenario["annual_savings"] > 0:
             print_success(
                 f"💰 RECOMMENDED: Comprehensive review scenario - "
                 f"{recommended_scenario['count']} snapshots, "
@@ -724,18 +674,18 @@ class EnhancedRDSSnapshotOptimizer:
                     {"header": "📸 Snapshots", "style": "green bold"},
                     {"header": "💾 Storage (GB)", "style": "yellow bold"},
                     {"header": "💰 Monthly Savings", "style": "red"},
-                    {"header": "💵 Annual Savings", "style": "red bold"}
-                ]
+                    {"header": "💵 Annual Savings", "style": "red bold"},
+                ],
             )
 
             for account_id, data in sorted(account_breakdown.items()):
-                annual_savings = data['monthly_cost'] * 12
+                annual_savings = data["monthly_cost"] * 12
                 account_table.add_row(
                     account_id,
-                    str(data['count']),
+                    str(data["count"]),
                     f"{data['storage_gb']:,}",
-                    format_cost(data['monthly_cost']),
-                    format_cost(annual_savings)
+                    format_cost(data["monthly_cost"]),
+                    format_cost(annual_savings),
                 )
 
             console.print(account_table)
@@ -744,7 +694,7 @@ class EnhancedRDSSnapshotOptimizer:
             target_account = "142964829704"
             if target_account in account_breakdown:
                 target_data = account_breakdown[target_account]
-                target_annual = target_data['monthly_cost'] * 12
+                target_annual = target_data["monthly_cost"] * 12
 
                 print_success(
                     f"🎯 Target Account {target_account}: "
@@ -754,7 +704,7 @@ class EnhancedRDSSnapshotOptimizer:
                 )
 
         # Enhanced detailed snapshot table with all requested columns
-        if recommended_scenario['snapshots']:
+        if recommended_scenario["snapshots"]:
             print_info(f"\n📋 Detailed Snapshot Analysis for Cleanup Candidates:")
 
             detailed_table = create_table(
@@ -768,38 +718,37 @@ class EnhancedRDSSnapshotOptimizer:
                     {"header": "🗑️ Can be Deleted", "style": "red bold"},
                     {"header": "⚙️ Type", "style": "magenta bold"},
                     {"header": "📅 Created", "style": "bright_blue"},
-                    {"header": "🏷️ Tags", "style": "dim"}
-                ]
+                    {"header": "🏷️ Tags", "style": "dim"},
+                ],
             )
 
             # Sort snapshots by account ID, then by age (oldest first)
             sorted_snapshots = sorted(
-                recommended_scenario['snapshots'],
-                key=lambda x: (x.get('AccountId', 'unknown'), -x.get('AgeDays', 0))
+                recommended_scenario["snapshots"], key=lambda x: (x.get("AccountId", "unknown"), -x.get("AgeDays", 0))
             )
 
             # Display first 50 snapshots to avoid overwhelming output
             display_limit = 50
             for i, snapshot in enumerate(sorted_snapshots[:display_limit]):
                 # Account ID
-                account_id = snapshot.get('AccountId', 'unknown')
+                account_id = snapshot.get("AccountId", "unknown")
 
                 # Snapshot ID
-                snapshot_id = snapshot.get('DBSnapshotIdentifier', 'unknown')
+                snapshot_id = snapshot.get("DBSnapshotIdentifier", "unknown")
 
                 # DB Instance ID
-                db_instance_id = snapshot.get('DBInstanceIdentifier', 'unknown')
+                db_instance_id = snapshot.get("DBInstanceIdentifier", "unknown")
 
                 # Size in GiB
-                size_gib = snapshot.get('AllocatedStorage', 0)
+                size_gib = snapshot.get("AllocatedStorage", 0)
 
                 # Can be Deleted analysis
-                age_days = snapshot.get('AgeDays', 0)
-                snapshot_type = snapshot.get('SnapshotType', 'unknown').lower()
+                age_days = snapshot.get("AgeDays", 0)
+                snapshot_type = snapshot.get("SnapshotType", "unknown").lower()
 
-                if snapshot_type == 'manual' and age_days >= age_threshold:
+                if snapshot_type == "manual" and age_days >= age_threshold:
                     can_delete = "✅ Yes (Manual)"
-                elif snapshot_type == 'automated' and age_days >= 365:
+                elif snapshot_type == "automated" and age_days >= 365:
                     can_delete = "⚠️ Review Policy"
                 elif age_days >= age_threshold:
                     can_delete = "📋 Needs Review"
@@ -807,28 +756,28 @@ class EnhancedRDSSnapshotOptimizer:
                     can_delete = "❌ Keep"
 
                 # Manual/Automated
-                type_display = "🔧 Manual" if snapshot_type == 'manual' else "🤖 Automated"
+                type_display = "🔧 Manual" if snapshot_type == "manual" else "🤖 Automated"
 
                 # Creation Time
-                create_time = snapshot.get('SnapshotCreateTime')
+                create_time = snapshot.get("SnapshotCreateTime")
                 if create_time:
                     if isinstance(create_time, str):
                         create_time_display = create_time[:10]  # YYYY-MM-DD
                     else:
-                        create_time_display = create_time.strftime('%Y-%m-%d')
+                        create_time_display = create_time.strftime("%Y-%m-%d")
                 else:
-                    create_time_display = 'unknown'
+                    create_time_display = "unknown"
 
                 # Tags
-                tag_list = snapshot.get('TagList', [])
+                tag_list = snapshot.get("TagList", [])
                 if tag_list and isinstance(tag_list, list):
                     # Display first 2 tags to avoid table width issues
-                    tag_names = [tag.get('Key', '') for tag in tag_list[:2] if isinstance(tag, dict)]
-                    tags_display = ', '.join(tag_names) if tag_names else 'None'
+                    tag_names = [tag.get("Key", "") for tag in tag_list[:2] if isinstance(tag, dict)]
+                    tags_display = ", ".join(tag_names) if tag_names else "None"
                     if len(tag_list) > 2:
-                        tags_display += f" (+{len(tag_list)-2})"
+                        tags_display += f" (+{len(tag_list) - 2})"
                 else:
-                    tags_display = 'None'
+                    tags_display = "None"
 
                 detailed_table.add_row(
                     account_id,
@@ -838,31 +787,28 @@ class EnhancedRDSSnapshotOptimizer:
                     can_delete,
                     type_display,
                     create_time_display,
-                    tags_display
+                    tags_display,
                 )
 
             console.print(detailed_table)
 
             # Show summary if we hit the display limit
-            total_candidates = len(recommended_scenario['snapshots'])
+            total_candidates = len(recommended_scenario["snapshots"])
             if total_candidates > display_limit:
-                print_info(
-                    f"📊 Showing top {display_limit} snapshots. "
-                    f"Total cleanup candidates: {total_candidates}"
-                )
+                print_info(f"📊 Showing top {display_limit} snapshots. Total cleanup candidates: {total_candidates}")
 
         # Return enhanced optimization results with multiple scenarios
         return {
-            'total_snapshots': len(snapshots),
-            'manual_snapshots': len(manual_snapshots),
-            'automated_snapshots': len(automated_snapshots),
-            'optimization_scenarios': optimization_results,
-            'account_breakdown': account_breakdown,
-            'target_account_data': account_breakdown.get("142964829704", {}),
+            "total_snapshots": len(snapshots),
+            "manual_snapshots": len(manual_snapshots),
+            "automated_snapshots": len(automated_snapshots),
+            "optimization_scenarios": optimization_results,
+            "account_breakdown": account_breakdown,
+            "target_account_data": account_breakdown.get("142964829704", {}),
             # Legacy compatibility (use comprehensive scenario as primary)
-            'cleanup_candidates': primary_scenario['count'],
-            'potential_monthly_savings': primary_scenario['monthly_cost'],
-            'potential_annual_savings': primary_scenario['annual_savings']
+            "cleanup_candidates": primary_scenario["count"],
+            "potential_monthly_savings": primary_scenario["monthly_cost"],
+            "potential_annual_savings": primary_scenario["annual_savings"],
         }
 
     def display_comprehensive_snapshot_table(self, snapshots: List[Dict], manual_only: bool = False) -> None:
@@ -879,18 +825,15 @@ class EnhancedRDSSnapshotOptimizer:
             return
 
         # Import embedded MCP validator
-        from .embedded_mcp_validator import EmbeddedMCPValidator
+        from .mcp_validator import EmbeddedMCPValidator
 
         # Initialize MCP validator
-        mcp_validator = EmbeddedMCPValidator(
-            profiles=[self.profile] if self.profile else [],
-            console=console
-        )
+        mcp_validator = EmbeddedMCPValidator(profiles=[self.profile] if self.profile else [], console=console)
 
         # Create comprehensive table
         table = create_table(
             title=f"RDS Snapshots Analysis ({len(snapshots)} total{'Manual only' if manual_only else ''})",
-            caption="Complete snapshot inventory with MCP validation"
+            caption="Complete snapshot inventory with MCP validation",
         )
 
         # Add columns as requested by user
@@ -905,32 +848,32 @@ class EnhancedRDSSnapshotOptimizer:
         table.add_column("MCP-checked", style="bright_green", justify="center", no_wrap=True)
 
         # Sort snapshots by creation time (oldest to newest)
-        sorted_snapshots = sorted(snapshots, key=lambda s: s.get('SnapshotCreateTime', ''))
+        sorted_snapshots = sorted(snapshots, key=lambda s: s.get("SnapshotCreateTime", ""))
 
         # Add rows for each snapshot
         for snapshot in sorted_snapshots:
             # Basic fields
-            account_id = snapshot.get('AccountId', 'unknown')
-            snapshot_id = snapshot.get('DBSnapshotIdentifier', 'unknown')
-            db_instance_id = snapshot.get('DBInstanceIdentifier', 'unknown')
-            size_gb = snapshot.get('AllocatedStorage', 0)
-            snapshot_type = snapshot.get('SnapshotType', 'unknown')
+            account_id = snapshot.get("AccountId", "unknown")
+            snapshot_id = snapshot.get("DBSnapshotIdentifier", "unknown")
+            db_instance_id = snapshot.get("DBInstanceIdentifier", "unknown")
+            size_gb = snapshot.get("AllocatedStorage", 0)
+            snapshot_type = snapshot.get("SnapshotType", "unknown")
 
             # Age-based deletion recommendation
-            age_days = snapshot.get('AgeDays', 0)
-            can_delete = "YES" if (snapshot_type == 'manual' and age_days > 90) else "NO"
+            age_days = snapshot.get("AgeDays", 0)
+            can_delete = "YES" if (snapshot_type == "manual" and age_days > 90) else "NO"
             can_delete_style = "[red]YES[/red]" if can_delete == "YES" else "[green]NO[/green]"
 
             # Manual/Automated display
-            type_display = "[yellow]Manual[/yellow]" if snapshot_type == 'manual' else "[blue]Automated[/blue]"
+            type_display = "[yellow]Manual[/yellow]" if snapshot_type == "manual" else "[blue]Automated[/blue]"
 
             # Creation time (formatted)
-            create_time = snapshot.get('SnapshotCreateTime', '')
+            create_time = snapshot.get("SnapshotCreateTime", "")
             if create_time:
                 try:
                     if isinstance(create_time, str):
-                        dt = datetime.fromisoformat(create_time.replace('Z', '+00:00'))
-                        create_time_display = dt.strftime('%Y-%m-%d')
+                        dt = datetime.fromisoformat(create_time.replace("Z", "+00:00"))
+                        create_time_display = dt.strftime("%Y-%m-%d")
                     else:
                         create_time_display = str(create_time)[:10]
                 except:
@@ -939,11 +882,11 @@ class EnhancedRDSSnapshotOptimizer:
                 create_time_display = "Unknown"
 
             # Tags (formatted)
-            tags = snapshot.get('TagList', [])
+            tags = snapshot.get("TagList", [])
             if tags and isinstance(tags, list):
                 tag_strs = []
                 for tag in tags[:2]:  # Show first 2 tags
-                    if isinstance(tag, dict) and 'Key' in tag:
+                    if isinstance(tag, dict) and "Key" in tag:
                         tag_strs.append(f"{tag['Key']}:{tag.get('Value', '')}")
                 tags_display = ", ".join(tag_strs)
                 if len(tags) > 2:
@@ -965,15 +908,15 @@ class EnhancedRDSSnapshotOptimizer:
                 type_display,
                 create_time_display,
                 tags_display,
-                mcp_display
+                mcp_display,
             )
 
         console.print(table)
 
         # Display summary statistics
-        manual_count = len([s for s in snapshots if s.get('SnapshotType') == 'manual'])
-        automated_count = len([s for s in snapshots if s.get('SnapshotType') == 'automated'])
-        total_size = sum(s.get('AllocatedStorage', 0) for s in snapshots)
+        manual_count = len([s for s in snapshots if s.get("SnapshotType") == "manual"])
+        automated_count = len([s for s in snapshots if s.get("SnapshotType") == "automated"])
+        total_size = sum(s.get("AllocatedStorage", 0) for s in snapshots)
 
         print_info(f"📊 Summary: {len(snapshots)} total snapshots ({manual_count} manual, {automated_count} automated)")
         print_info(f"💾 Total Storage: {total_size:,} GiB")
@@ -985,12 +928,12 @@ class EnhancedRDSSnapshotOptimizer:
         """
         try:
             # Basic validation - check if snapshot data is consistent
-            required_fields = ['DBSnapshotIdentifier', 'AccountId', 'AllocatedStorage']
+            required_fields = ["DBSnapshotIdentifier", "AccountId", "AllocatedStorage"]
             has_required = all(snapshot.get(field) for field in required_fields)
 
             # Additional checks
-            size_valid = isinstance(snapshot.get('AllocatedStorage'), int) and snapshot.get('AllocatedStorage', 0) > 0
-            account_valid = len(str(snapshot.get('AccountId', ''))) == 12
+            size_valid = isinstance(snapshot.get("AllocatedStorage"), int) and snapshot.get("AllocatedStorage", 0) > 0
+            account_valid = len(str(snapshot.get("AccountId", ""))) == 12
 
             return has_required and size_valid and account_valid
         except Exception:
@@ -1000,7 +943,7 @@ class EnhancedRDSSnapshotOptimizer:
         """Original Config aggregator discovery method"""
         try:
             # Use ap-southeast-2 where organization aggregator is configured
-            config_client = self.session.client('config', region_name='ap-southeast-2')
+            config_client = self.session.client("config", region_name="ap-southeast-2")
 
             print_info("🔍 Discovering RDS snapshots via AWS Config organization aggregator...")
 
@@ -1033,19 +976,19 @@ class EnhancedRDSSnapshotOptimizer:
 
                 while True:
                     query_params = {
-                        'ConfigurationAggregatorName': 'organization-aggregator',
-                        'Expression': query_expression,
-                        'Limit': 100  # Maximum allowed by Config API
+                        "ConfigurationAggregatorName": "organization-aggregator",
+                        "Expression": query_expression,
+                        "Limit": 100,  # Maximum allowed by Config API
                     }
 
                     if next_token:
-                        query_params['NextToken'] = next_token
+                        query_params["NextToken"] = next_token
 
                     response = config_client.select_aggregate_resource_config(**query_params)
-                    results = response.get('Results', [])
+                    results = response.get("Results", [])
                     all_results.extend(results)
 
-                    next_token = response.get('NextToken')
+                    next_token = response.get("NextToken")
                     if not next_token:
                         break
 
@@ -1063,33 +1006,40 @@ class EnhancedRDSSnapshotOptimizer:
 
         # User's 8 test accounts
         test_accounts = {
-            '91893567291', '142964829704', '363435891329', '507583929055',
-            '614294421455', '695366013198', '761860562159', '802669565615'
+            "91893567291",
+            "142964829704",
+            "363435891329",
+            "507583929055",
+            "614294421455",
+            "695366013198",
+            "761860562159",
+            "802669565615",
         }
 
         discovered_snapshots = []
 
         # Test regions where snapshots might exist
-        regions = ['ap-southeast-2', 'us-east-1', 'us-west-2', 'eu-west-1']
+        regions = ["ap-southeast-2", "us-east-1", "us-west-2", "eu-west-1"]
 
         for region in regions:
             try:
-                rds_client = self.session.client('rds', region_name=region)
+                rds_client = self.session.client("rds", region_name=region)
                 print_info(f"🌏 Scanning region {region}...")
 
                 # Get snapshots
-                paginator = rds_client.get_paginator('describe_db_snapshots')
+                paginator = rds_client.get_paginator("describe_db_snapshots")
 
-                snapshot_type = 'manual' if manual_only else 'all'
-                page_iterator = paginator.paginate(
-                    SnapshotType=snapshot_type,
-                    MaxRecords=100
-                )
+                snapshot_type = "manual" if manual_only else "all"
+                page_iterator = paginator.paginate(SnapshotType=snapshot_type, MaxRecords=100)
 
                 for page in page_iterator:
-                    for snapshot in page.get('DBSnapshots', []):
+                    for snapshot in page.get("DBSnapshots", []):
                         # Extract account from ARN
-                        account_id = snapshot.get('DBSnapshotArn', '').split(':')[4] if snapshot.get('DBSnapshotArn') else 'unknown'
+                        account_id = (
+                            snapshot.get("DBSnapshotArn", "").split(":")[4]
+                            if snapshot.get("DBSnapshotArn")
+                            else "unknown"
+                        )
 
                         # Filter for test accounts if no specific target, or match target
                         if target_account_id:
@@ -1111,44 +1061,46 @@ class EnhancedRDSSnapshotOptimizer:
         try:
             # Map RDS API fields to our standardized format
             processed_snapshot = {
-                'DBSnapshotIdentifier': rds_snapshot.get('DBSnapshotIdentifier'),
-                'DBInstanceIdentifier': rds_snapshot.get('DBInstanceIdentifier'),
-                'SnapshotCreateTime': rds_snapshot.get('SnapshotCreateTime'),
-                'Engine': rds_snapshot.get('Engine'),
-                'AllocatedStorage': rds_snapshot.get('AllocatedStorage'),
-                'Status': rds_snapshot.get('Status'),
-                'Port': rds_snapshot.get('Port'),
-                'SnapshotType': rds_snapshot.get('SnapshotType'),
-                'Encrypted': rds_snapshot.get('Encrypted'),
-                'KmsKeyId': rds_snapshot.get('KmsKeyId'),
-                'TagList': rds_snapshot.get('TagList', []),
-                'Region': rds_snapshot.get('AvailabilityZone', '').split('-')[0] if rds_snapshot.get('AvailabilityZone') else 'unknown',
-                'DiscoveryMethod': 'direct_rds_api'
+                "DBSnapshotIdentifier": rds_snapshot.get("DBSnapshotIdentifier"),
+                "DBInstanceIdentifier": rds_snapshot.get("DBInstanceIdentifier"),
+                "SnapshotCreateTime": rds_snapshot.get("SnapshotCreateTime"),
+                "Engine": rds_snapshot.get("Engine"),
+                "AllocatedStorage": rds_snapshot.get("AllocatedStorage"),
+                "Status": rds_snapshot.get("Status"),
+                "Port": rds_snapshot.get("Port"),
+                "SnapshotType": rds_snapshot.get("SnapshotType"),
+                "Encrypted": rds_snapshot.get("Encrypted"),
+                "KmsKeyId": rds_snapshot.get("KmsKeyId"),
+                "TagList": rds_snapshot.get("TagList", []),
+                "Region": rds_snapshot.get("AvailabilityZone", "").split("-")[0]
+                if rds_snapshot.get("AvailabilityZone")
+                else "unknown",
+                "DiscoveryMethod": "direct_rds_api",
             }
 
             # Extract account from ARN
-            arn = rds_snapshot.get('DBSnapshotArn', '')
+            arn = rds_snapshot.get("DBSnapshotArn", "")
             if arn:
-                account_id = arn.split(':')[4]
-                processed_snapshot['AccountId'] = account_id
+                account_id = arn.split(":")[4]
+                processed_snapshot["AccountId"] = account_id
 
             # Calculate age and costs
-            snapshot_create_time = processed_snapshot.get('SnapshotCreateTime')
+            snapshot_create_time = processed_snapshot.get("SnapshotCreateTime")
             if snapshot_create_time:
                 if isinstance(snapshot_create_time, str):
-                    create_time = datetime.fromisoformat(snapshot_create_time.replace('Z', '+00:00'))
+                    create_time = datetime.fromisoformat(snapshot_create_time.replace("Z", "+00:00"))
                 else:
                     create_time = snapshot_create_time
 
                 age_days = (datetime.now(timezone.utc) - create_time).days
-                processed_snapshot['AgeDays'] = age_days
+                processed_snapshot["AgeDays"] = age_days
 
                 # Calculate costs
-                allocated_storage = processed_snapshot.get('AllocatedStorage', 0)
+                allocated_storage = processed_snapshot.get("AllocatedStorage", 0)
                 if allocated_storage > 0:
                     monthly_cost = allocated_storage * 0.095  # Use fallback pricing
-                    processed_snapshot['EstimatedMonthlyCost'] = round(monthly_cost, 2)
-                    processed_snapshot['EstimatedAnnualCost'] = round(monthly_cost * 12, 2)
+                    processed_snapshot["EstimatedMonthlyCost"] = round(monthly_cost, 2)
+                    processed_snapshot["EstimatedAnnualCost"] = round(monthly_cost * 12, 2)
 
             return processed_snapshot
 
@@ -1158,16 +1110,16 @@ class EnhancedRDSSnapshotOptimizer:
 
 
 @click.command()
-@click.option('--all', '-a', is_flag=True, help='Organization-wide discovery using management profile')
-@click.option('--profile', help='AWS profile for authentication or target account ID for filtering')
-@click.option('--target-account', help='[DEPRECATED] Use --profile instead. Target account ID for filtering')
-@click.option('--age-threshold', type=int, default=90, help='Age threshold for cleanup (days)')
-@click.option('--days', type=int, help='Age threshold in days (alias for --age-threshold)')
-@click.option('--aging', type=int, help='Age threshold in days (alias for --age-threshold)')
-@click.option('--manual', is_flag=True, help='Filter only manual snapshots (exclude automated)')
-@click.option('--dry-run/--execute', default=True, help='Analysis mode vs execution mode')
-@click.option('--output-file', help='Export results to CSV file')
-@click.option('--analyze', is_flag=True, help='Perform comprehensive optimization analysis')
+@click.option("--all", "-a", is_flag=True, help="Organization-wide discovery using management profile")
+@click.option("--profile", help="AWS profile for authentication or target account ID for filtering")
+@click.option("--target-account", help="[DEPRECATED] Use --profile instead. Target account ID for filtering")
+@click.option("--age-threshold", type=int, default=90, help="Age threshold for cleanup (days)")
+@click.option("--days", type=int, help="Age threshold in days (alias for --age-threshold)")
+@click.option("--aging", type=int, help="Age threshold in days (alias for --age-threshold)")
+@click.option("--manual", is_flag=True, help="Filter only manual snapshots (exclude automated)")
+@click.option("--dry-run/--execute", default=True, help="Analysis mode vs execution mode")
+@click.option("--output-file", help="Export results to CSV file")
+@click.option("--analyze", is_flag=True, help="Perform comprehensive optimization analysis")
 def optimize_rds_snapshots(
     all: bool,
     profile: str,
@@ -1178,7 +1130,7 @@ def optimize_rds_snapshots(
     manual: bool,
     dry_run: bool,
     output_file: str,
-    analyze: bool
+    analyze: bool,
 ):
     """
     Enhanced RDS Snapshot Cost Optimizer
@@ -1213,7 +1165,7 @@ def optimize_rds_snapshots(
                 print_info(f"🌐 Organization-wide discovery using profile: {profile}")
             else:
                 # Default to MANAGEMENT_PROFILE environment variable or current profile
-                auth_profile = os.getenv('MANAGEMENT_PROFILE')
+                auth_profile = os.getenv("MANAGEMENT_PROFILE")
                 if auth_profile:
                     print_info(f"🌐 Organization-wide discovery using MANAGEMENT_PROFILE: {auth_profile}")
                 else:
@@ -1233,14 +1185,14 @@ def optimize_rds_snapshots(
             elif target_account:
                 print_warning("🚨 [DEPRECATED] --target-account is deprecated. Use --profile instead")
                 target_account_id = target_account
-                auth_profile = os.getenv('MANAGEMENT_PROFILE') or profile
+                auth_profile = os.getenv("MANAGEMENT_PROFILE") or profile
                 print_info(f"🎯 Target account analysis (deprecated): {target_account_id}")
             elif profile:
                 # Check if profile looks like account ID vs profile name
                 if profile.isdigit() and len(profile) == 12:
                     target_account_id = profile
                     # Use management profile for authentication when targeting specific account
-                    auth_profile = os.getenv('MANAGEMENT_PROFILE') or 'ams-admin-ReadOnlyAccess-909135376185'
+                    auth_profile = os.getenv("MANAGEMENT_PROFILE") or "${MANAGEMENT_PROFILE}"
                     print_info(f"🎯 Target account analysis: {target_account_id}")
                     print_info(f"🔐 Authentication via: {auth_profile}")
                 else:
@@ -1271,8 +1223,7 @@ def optimize_rds_snapshots(
 
         # Discover snapshots via Config aggregator
         snapshots = optimizer.discover_snapshots_via_config_aggregator(
-            target_account_id=target_account_id,
-            manual_only=manual
+            target_account_id=target_account_id, manual_only=manual
         )
 
         if not snapshots:
@@ -1288,25 +1239,23 @@ def optimize_rds_snapshots(
 
             # Summary panel
             panel_content = f"""
-📊 Discovery Results: {optimization_results['total_snapshots']} total snapshots
-💾 Manual Snapshots: {optimization_results['manual_snapshots']} (review candidates)
-🎯 Cleanup Candidates: {optimization_results['cleanup_candidates']} (>{final_age_threshold} days)
-💰 Potential Savings: {format_cost(optimization_results['potential_annual_savings'])} annually
+📊 Discovery Results: {optimization_results["total_snapshots"]} total snapshots
+💾 Manual Snapshots: {optimization_results["manual_snapshots"]} (review candidates)
+🎯 Cleanup Candidates: {optimization_results["cleanup_candidates"]} (>{final_age_threshold} days)
+💰 Potential Savings: {format_cost(optimization_results["potential_annual_savings"])} annually
             """
 
-            console.print(create_panel(
-                panel_content.strip(),
-                title="RDS Snapshot Optimization Summary",
-                border_style="green"
-            ))
+            console.print(
+                create_panel(panel_content.strip(), title="RDS Snapshot Optimization Summary", border_style="green")
+            )
 
             # Display comprehensive snapshot table
             optimizer.display_comprehensive_snapshot_table(snapshots, manual_only=manual)
 
             # Target account specific results
-            if target_account and optimization_results['target_account_data']:
-                target_data = optimization_results['target_account_data']
-                target_annual = target_data['monthly_cost'] * 12
+            if target_account and optimization_results["target_account_data"]:
+                target_data = optimization_results["target_account_data"]
+                target_annual = target_data["monthly_cost"] * 12
 
                 print_success(
                     f"🎯 Target Account {target_account} Results: "
@@ -1318,9 +1267,9 @@ def optimize_rds_snapshots(
         if output_file:
             export_results(snapshots, output_file, optimization_results if analyze else None)
 
-        # JIRA FinOps-23 validation
+        # Cost optimization validation
         if analyze:
-            validate_jira_targets(optimization_results)
+            _validate_cost_targets(optimization_results)
 
     except Exception as e:
         print_error(f"RDS snapshot optimization failed: {e}")
@@ -1332,12 +1281,21 @@ def export_results(snapshots: List[Dict], output_file: str, optimization_results
     try:
         import csv
 
-        with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
+        with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
             # Define CSV fieldnames
             fieldnames = [
-                'DBSnapshotIdentifier', 'AccountId', 'Region', 'SnapshotType',
-                'AgeDays', 'AllocatedStorage', 'EstimatedMonthlyCost', 'EstimatedAnnualCost',
-                'Engine', 'Status', 'Encrypted', 'DiscoveryMethod'
+                "DBSnapshotIdentifier",
+                "AccountId",
+                "Region",
+                "SnapshotType",
+                "AgeDays",
+                "AllocatedStorage",
+                "EstimatedMonthlyCost",
+                "EstimatedAnnualCost",
+                "Engine",
+                "Status",
+                "Encrypted",
+                "DiscoveryMethod",
             ]
 
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
@@ -1345,45 +1303,43 @@ def export_results(snapshots: List[Dict], output_file: str, optimization_results
 
             for snapshot in snapshots:
                 # Create row with only the fieldnames we want
-                row = {field: snapshot.get(field, '') for field in fieldnames}
+                row = {field: snapshot.get(field, "") for field in fieldnames}
                 writer.writerow(row)
 
         print_success(f"✅ Exported {len(snapshots)} snapshots to {output_file}")
 
         if optimization_results:
-            print_info(f"📊 Optimization potential: {format_cost(optimization_results['potential_annual_savings'])} annually")
+            print_info(
+                f"📊 Optimization potential: {format_cost(optimization_results['potential_annual_savings'])} annually"
+            )
 
     except Exception as e:
         print_error(f"Failed to export results: {e}")
 
 
-def validate_jira_targets(optimization_results: Dict) -> None:
-    """Validate against JIRA FinOps-23 targets ($5K-24K annual savings)"""
+def _validate_cost_targets(optimization_results: Dict) -> None:
+    """Validate cost optimization targets for measurable annual savings"""
     target_min = 5000.0
     target_max = 24000.0
-    actual_savings = optimization_results['potential_annual_savings']
+    actual_savings = optimization_results["potential_annual_savings"]
 
     if actual_savings >= target_min:
         if actual_savings <= target_max:
             print_success(
-                f"🎯 JIRA FinOps-23 Target Achievement: "
+                f"🎯 Cost Target Achievement: "
                 f"${actual_savings:,.0f} within target range "
                 f"(${target_min:,.0f}-${target_max:,.0f})"
             )
         else:
             print_success(
-                f"🎯 JIRA FinOps-23 Target Exceeded: "
-                f"${actual_savings:,.0f} exceeds maximum target "
-                f"(${target_max:,.0f})"
+                f"🎯 Cost Target Exceeded: ${actual_savings:,.0f} exceeds maximum target (${target_max:,.0f})"
             )
     else:
         percentage = (actual_savings / target_min) * 100
         print_warning(
-            f"📊 JIRA FinOps-23 Analysis: "
-            f"${actual_savings:,.0f} is {percentage:.1f}% of minimum target "
-            f"(${target_min:,.0f})"
+            f"📊 Cost Analysis: ${actual_savings:,.0f} is {percentage:.1f}% of minimum target (${target_min:,.0f})"
         )
 
 
 if __name__ == "__main__":
-    optimize_rds_snapshots()
+    optimize_rds_snapshots()