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

runbooks/inventory/list_rds_snapshots_aggregator.py

@@ -29,8 +29,15 @@ import boto3
 from botocore.exceptions import ClientError, NoCredentialsError
 
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
 )
 from ..common.profile_utils import get_profile_for_operation
 
@@ -58,8 +65,13 @@ class RDSSnapshotConfigAggregator:
 
         # Config aggregator regions for comprehensive coverage
         self.config_regions = [
-            'us-east-1', 'us-west-2', 'eu-west-1', 'ap-southeast-2',
-            'ap-northeast-1', 'ca-central-1', 'eu-central-1'
+            "us-east-1",
+            "us-west-2",
+            "eu-west-1",
+            "ap-southeast-2",
+            "ap-northeast-1",
+            "ca-central-1",
+            "eu-central-1",
         ]
 
         # Session management
@@ -69,12 +81,12 @@ class RDSSnapshotConfigAggregator:
 
         # Performance metrics
         self.metrics = {
-            'aggregators_found': 0,
-            'snapshots_discovered': 0,
-            'accounts_covered': 0,
-            'regions_scanned': 0,
-            'api_calls_made': 0,
-            'errors_encountered': 0
+            "aggregators_found": 0,
+            "snapshots_discovered": 0,
+            "accounts_covered": 0,
+            "regions_scanned": 0,
+            "api_calls_made": 0,
+            "errors_encountered": 0,
         }
 
     def initialize_session(self) -> bool:
@@ -84,7 +96,7 @@ class RDSSnapshotConfigAggregator:
             self.session = boto3.Session(profile_name=profile)
 
             # Verify access with STS
-            sts_client = self.session.client('sts')
+            sts_client = self.session.client("sts")
             identity = sts_client.get_caller_identity()
 
             print_success(f"✅ Initialized session with profile: {profile}")
@@ -108,15 +120,11 @@ class RDSSnapshotConfigAggregator:
         aggregator_map = {}
 
         with create_progress_bar() as progress:
-            task_id = progress.add_task(
-                "Scanning regions for Config aggregators...",
-                total=len(self.config_regions)
-            )
+            task_id = progress.add_task("Scanning regions for Config aggregators...", total=len(self.config_regions))
 
             with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
                 future_to_region = {
-                    executor.submit(self._find_aggregators_in_region, region): region
-                    for region in self.config_regions
+                    executor.submit(self._find_aggregators_in_region, region): region for region in self.config_regions
                 }
 
                 for future in as_completed(future_to_region):
@@ -125,16 +133,16 @@ class RDSSnapshotConfigAggregator:
                         aggregators = future.result()
                         if aggregators:
                             aggregator_map[region] = aggregators
-                            self.metrics['aggregators_found'] += len(aggregators)
+                            self.metrics["aggregators_found"] += len(aggregators)
                             console.print(f"[green]✓[/green] {region}: Found {len(aggregators)} aggregator(s)")
                         else:
                             console.print(f"[dim]○[/dim] {region}: No aggregators found")
 
-                        self.metrics['regions_scanned'] += 1
+                        self.metrics["regions_scanned"] += 1
 
                     except Exception as e:
                         print_warning(f"❌ {region}: {str(e)}")
-                        self.metrics['errors_encountered'] += 1
+                        self.metrics["errors_encountered"] += 1
 
                     progress.advance(task_id)
 
@@ -152,28 +160,28 @@ class RDSSnapshotConfigAggregator:
     def _find_aggregators_in_region(self, region: str) -> List[str]:
         """Find Config aggregators in a specific region"""
         try:
-            config_client = self.session.client('config', region_name=region)
+            config_client = self.session.client("config", region_name=region)
 
             # List configuration aggregators
             response = config_client.describe_configuration_aggregators()
-            self.metrics['api_calls_made'] += 1
+            self.metrics["api_calls_made"] += 1
 
             aggregators = []
-            for aggregator in response.get('ConfigurationAggregators', []):
-                aggregator_name = aggregator['ConfigurationAggregatorName']
+            for aggregator in response.get("ConfigurationAggregators", []):
+                aggregator_name = aggregator["ConfigurationAggregatorName"]
                 aggregators.append(aggregator_name)
 
                 # Log aggregator details for debugging
                 logger.debug(f"Found aggregator {aggregator_name} in {region}")
-                if 'OrganizationAggregationSource' in aggregator:
-                    org_source = aggregator['OrganizationAggregationSource']
+                if "OrganizationAggregationSource" in aggregator:
+                    org_source = aggregator["OrganizationAggregationSource"]
                     logger.debug(f"Organization aggregator: AllAwsRegions={org_source.get('AllAwsRegions', False)}")
 
             return aggregators
 
         except ClientError as e:
-            error_code = e.response['Error']['Code']
-            if error_code in ['AccessDenied', 'UnauthorizedOperation']:
+            error_code = e.response["Error"]["Code"]
+            if error_code in ["AccessDenied", "UnauthorizedOperation"]:
                 logger.debug(f"No Config access in {region}: {error_code}")
             else:
                 logger.warning(f"Config API error in {region}: {e}")
@@ -207,23 +215,18 @@ class RDSSnapshotConfigAggregator:
         # Process each region's aggregators
         with create_progress_bar() as progress:
             total_aggregators = sum(len(aggs) for aggs in self.discovered_aggregators.values())
-            task_id = progress.add_task(
-                "Discovering RDS snapshots via Config aggregators...",
-                total=total_aggregators
-            )
+            task_id = progress.add_task("Discovering RDS snapshots via Config aggregators...", total=total_aggregators)
 
             for region, aggregators in self.discovered_aggregators.items():
                 console.print(f"\n[cyan]🔍 Processing Config aggregators in {region}[/cyan]")
 
                 for aggregator_name in aggregators:
                     try:
-                        snapshots = self._query_snapshots_from_aggregator(
-                            region, aggregator_name, target_account_ids
-                        )
+                        snapshots = self._query_snapshots_from_aggregator(region, aggregator_name, target_account_ids)
 
                         if snapshots:
                             all_snapshots.extend(snapshots)
-                            unique_accounts = set(s.get('AccountId', 'unknown') for s in snapshots)
+                            unique_accounts = set(s.get("AccountId", "unknown") for s in snapshots)
                             console.print(
                                 f"[green]✓[/green] {aggregator_name}: "
                                 f"Found {len(snapshots)} snapshots across {len(unique_accounts)} accounts"
@@ -233,20 +236,19 @@ class RDSSnapshotConfigAggregator:
 
                     except Exception as e:
                         print_warning(f"❌ {aggregator_name}: {str(e)}")
-                        self.metrics['errors_encountered'] += 1
+                        self.metrics["errors_encountered"] += 1
 
                     progress.advance(task_id)
 
         # Update metrics
-        self.metrics['snapshots_discovered'] = len(all_snapshots)
-        unique_accounts = set(s.get('AccountId', 'unknown') for s in all_snapshots)
-        self.metrics['accounts_covered'] = len(unique_accounts)
+        self.metrics["snapshots_discovered"] = len(all_snapshots)
+        unique_accounts = set(s.get("AccountId", "unknown") for s in all_snapshots)
+        self.metrics["accounts_covered"] = len(unique_accounts)
 
         # Summary
         if all_snapshots:
             print_success(
-                f"✅ Discovery complete: {len(all_snapshots)} RDS snapshots "
-                f"across {len(unique_accounts)} accounts"
+                f"✅ Discovery complete: {len(all_snapshots)} RDS snapshots across {len(unique_accounts)} accounts"
             )
         else:
             print_warning("⚠️ No RDS snapshots discovered via Config aggregators")
@@ -255,14 +257,11 @@ class RDSSnapshotConfigAggregator:
         return all_snapshots
 
     def _query_snapshots_from_aggregator(
-        self,
-        region: str,
-        aggregator_name: str,
-        target_account_ids: Optional[List[str]] = None
+        self, region: str, aggregator_name: str, target_account_ids: Optional[List[str]] = None
     ) -> List[Dict]:
         """Query RDS snapshots from a specific Config aggregator"""
         try:
-            config_client = self.session.client('config', region_name=region)
+            config_client = self.session.client("config", region_name=region)
 
             # Base query for RDS DB snapshots
             query_expression = """
@@ -290,19 +289,19 @@ class RDSSnapshotConfigAggregator:
 
             while True:
                 query_params = {
-                    'ConfigurationAggregatorName': aggregator_name,
-                    'Expression': query_expression,
-                    'Limit': 100  # Maximum allowed by Config API
+                    "ConfigurationAggregatorName": aggregator_name,
+                    "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)
-                self.metrics['api_calls_made'] += 1
+                self.metrics["api_calls_made"] += 1
 
                 # Process results
-                for result in response.get('Results', []):
+                for result in response.get("Results", []):
                     try:
                         snapshot_data = json.loads(result)
                         processed_snapshot = self._process_config_snapshot_result(snapshot_data)
@@ -314,17 +313,17 @@ class RDSSnapshotConfigAggregator:
                         logger.warning(f"Failed to process snapshot data: {e}")
 
                 # Check for more results
-                next_token = response.get('NextToken')
+                next_token = response.get("NextToken")
                 if not next_token:
                     break
 
             return snapshots
 
         except ClientError as e:
-            error_code = e.response['Error']['Code']
-            if error_code == 'NoSuchConfigurationAggregatorException':
+            error_code = e.response["Error"]["Code"]
+            if error_code == "NoSuchConfigurationAggregatorException":
                 logger.warning(f"Aggregator {aggregator_name} not found in {region}")
-            elif error_code in ['AccessDenied', 'UnauthorizedOperation']:
+            elif error_code in ["AccessDenied", "UnauthorizedOperation"]:
                 logger.warning(f"Access denied to aggregator {aggregator_name} in {region}")
             else:
                 logger.error(f"Config aggregator query failed: {e}")
@@ -338,16 +337,16 @@ class RDSSnapshotConfigAggregator:
         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 if available
-            configuration = config_data.get('configuration', {})
+            configuration = config_data.get("configuration", {})
             if isinstance(configuration, str):
                 try:
                     configuration = json.loads(configuration)
@@ -356,55 +355,57 @@ class RDSSnapshotConfigAggregator:
 
             # Extract RDS-specific details
             if configuration:
-                snapshot_info.update({
-                    'DBInstanceIdentifier': configuration.get('dBInstanceIdentifier', 'unknown'),
-                    'SnapshotType': configuration.get('snapshotType', 'unknown'),
-                    'Status': configuration.get('status', 'unknown'),
-                    'Engine': configuration.get('engine', 'unknown'),
-                    'EngineVersion': configuration.get('engineVersion', 'unknown'),
-                    'AllocatedStorage': configuration.get('allocatedStorage', 0),
-                    'StorageType': configuration.get('storageType', 'unknown'),
-                    'Encrypted': configuration.get('encrypted', False),
-                    'SnapshotCreateTime': configuration.get('snapshotCreateTime'),
-                    'InstanceCreateTime': configuration.get('instanceCreateTime'),
-                    'MasterUsername': configuration.get('masterUsername', 'unknown'),
-                    'Port': configuration.get('port', 0),
-                    'VpcId': configuration.get('vpcId'),
-                    'AvailabilityZone': configuration.get('availabilityZone'),
-                    'LicenseModel': configuration.get('licenseModel', 'unknown'),
-                    'OptionGroupName': configuration.get('optionGroupName'),
-                    'PercentProgress': configuration.get('percentProgress', 0),
-                    'SourceRegion': configuration.get('sourceRegion'),
-                    'SourceDBSnapshotIdentifier': configuration.get('sourceDBSnapshotIdentifier'),
-                    'StorageEncrypted': configuration.get('storageEncrypted', False),
-                    'KmsKeyId': configuration.get('kmsKeyId'),
-                    'Timezone': configuration.get('timezone'),
-                    'IAMDatabaseAuthenticationEnabled': configuration.get('iAMDatabaseAuthenticationEnabled', False),
-                    'ProcessorFeatures': configuration.get('processorFeatures', []),
-                    'DbiResourceId': configuration.get('dbiResourceId'),
-                    'TagList': configuration.get('tagList', [])
-                })
+                snapshot_info.update(
+                    {
+                        "DBInstanceIdentifier": configuration.get("dBInstanceIdentifier", "unknown"),
+                        "SnapshotType": configuration.get("snapshotType", "unknown"),
+                        "Status": configuration.get("status", "unknown"),
+                        "Engine": configuration.get("engine", "unknown"),
+                        "EngineVersion": configuration.get("engineVersion", "unknown"),
+                        "AllocatedStorage": configuration.get("allocatedStorage", 0),
+                        "StorageType": configuration.get("storageType", "unknown"),
+                        "Encrypted": configuration.get("encrypted", False),
+                        "SnapshotCreateTime": configuration.get("snapshotCreateTime"),
+                        "InstanceCreateTime": configuration.get("instanceCreateTime"),
+                        "MasterUsername": configuration.get("masterUsername", "unknown"),
+                        "Port": configuration.get("port", 0),
+                        "VpcId": configuration.get("vpcId"),
+                        "AvailabilityZone": configuration.get("availabilityZone"),
+                        "LicenseModel": configuration.get("licenseModel", "unknown"),
+                        "OptionGroupName": configuration.get("optionGroupName"),
+                        "PercentProgress": configuration.get("percentProgress", 0),
+                        "SourceRegion": configuration.get("sourceRegion"),
+                        "SourceDBSnapshotIdentifier": configuration.get("sourceDBSnapshotIdentifier"),
+                        "StorageEncrypted": configuration.get("storageEncrypted", False),
+                        "KmsKeyId": configuration.get("kmsKeyId"),
+                        "Timezone": configuration.get("timezone"),
+                        "IAMDatabaseAuthenticationEnabled": configuration.get(
+                            "iAMDatabaseAuthenticationEnabled", False
+                        ),
+                        "ProcessorFeatures": configuration.get("processorFeatures", []),
+                        "DbiResourceId": configuration.get("dbiResourceId"),
+                        "TagList": configuration.get("tagList", []),
+                    }
+                )
 
             # Calculate age and estimated cost
-            if snapshot_info.get('SnapshotCreateTime'):
+            if snapshot_info.get("SnapshotCreateTime"):
                 try:
-                    create_time = datetime.fromisoformat(
-                        snapshot_info['SnapshotCreateTime'].replace('Z', '+00:00')
-                    )
+                    create_time = datetime.fromisoformat(snapshot_info["SnapshotCreateTime"].replace("Z", "+00:00"))
                     age_days = (datetime.now(timezone.utc) - create_time).days
-                    snapshot_info['AgeDays'] = age_days
+                    snapshot_info["AgeDays"] = age_days
 
                     # Estimate storage cost (basic calculation)
-                    allocated_storage = snapshot_info.get('AllocatedStorage', 0)
+                    allocated_storage = snapshot_info.get("AllocatedStorage", 0)
                     if allocated_storage > 0:
                         # Basic cost estimation - $0.095 per GB-month for snapshot storage
                         monthly_cost = allocated_storage * 0.095
-                        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)
 
                 except Exception as e:
                     logger.debug(f"Failed to calculate snapshot age: {e}")
-                    snapshot_info['AgeDays'] = 0
+                    snapshot_info["AgeDays"] = 0
 
             return snapshot_info
 
@@ -418,7 +419,7 @@ class RDSSnapshotConfigAggregator:
         account_filter: Optional[List[str]] = None,
         age_filter_days: Optional[int] = None,
         snapshot_type_filter: Optional[str] = None,
-        engine_filter: Optional[str] = None
+        engine_filter: Optional[str] = None,
     ) -> List[Dict]:
         """
         Apply filters to discovered snapshots
@@ -437,34 +438,24 @@ class RDSSnapshotConfigAggregator:
 
         # Account filter
         if account_filter:
-            filtered_snapshots = [
-                s for s in filtered_snapshots
-                if s.get('AccountId') in account_filter
-            ]
+            filtered_snapshots = [s for s in filtered_snapshots if s.get("AccountId") in account_filter]
             console.print(f"[dim]Account filter: {len(filtered_snapshots)} snapshots[/dim]")
 
         # Age filter
         if age_filter_days is not None:
-            filtered_snapshots = [
-                s for s in filtered_snapshots
-                if s.get('AgeDays', 0) >= age_filter_days
-            ]
+            filtered_snapshots = [s for s in filtered_snapshots if s.get("AgeDays", 0) >= age_filter_days]
             console.print(f"[dim]Age filter (>{age_filter_days}d): {len(filtered_snapshots)} snapshots[/dim]")
 
         # Snapshot type filter
         if snapshot_type_filter:
             filtered_snapshots = [
-                s for s in filtered_snapshots
-                if s.get('SnapshotType', '').lower() == snapshot_type_filter.lower()
+                s for s in filtered_snapshots if s.get("SnapshotType", "").lower() == snapshot_type_filter.lower()
             ]
             console.print(f"[dim]Type filter ({snapshot_type_filter}): {len(filtered_snapshots)} snapshots[/dim]")
 
         # Engine filter
         if engine_filter:
-            filtered_snapshots = [
-                s for s in filtered_snapshots
-                if engine_filter.lower() in s.get('Engine', '').lower()
-            ]
+            filtered_snapshots = [s for s in filtered_snapshots if engine_filter.lower() in s.get("Engine", "").lower()]
             console.print(f"[dim]Engine filter ({engine_filter}): {len(filtered_snapshots)} snapshots[/dim]")
 
         return filtered_snapshots
@@ -472,67 +463,66 @@ class RDSSnapshotConfigAggregator:
     def generate_summary_report(self, snapshots: List[Dict]) -> Dict:
         """Generate comprehensive summary report of discovered snapshots"""
         if not snapshots:
-            return {
-                'total_snapshots': 0,
-                'summary': 'No snapshots discovered'
-            }
+            return {"total_snapshots": 0, "summary": "No snapshots discovered"}
 
         # Basic statistics
         total_snapshots = len(snapshots)
-        unique_accounts = set(s.get('AccountId', 'unknown') for s in snapshots)
-        unique_regions = set(s.get('Region', 'unknown') for s in snapshots)
-        unique_engines = set(s.get('Engine', 'unknown') for s in snapshots)
+        unique_accounts = set(s.get("AccountId", "unknown") for s in snapshots)
+        unique_regions = set(s.get("Region", "unknown") for s in snapshots)
+        unique_engines = set(s.get("Engine", "unknown") for s in snapshots)
 
         # Snapshot type breakdown
-        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"]
 
         # Age analysis
-        aged_snapshots = [s for s in snapshots if s.get('AgeDays', 0) >= 90]  # 3+ months
-        very_old_snapshots = [s for s in snapshots if s.get('AgeDays', 0) >= 180]  # 6+ months
+        aged_snapshots = [s for s in snapshots if s.get("AgeDays", 0) >= 90]  # 3+ months
+        very_old_snapshots = [s for s in snapshots if s.get("AgeDays", 0) >= 180]  # 6+ months
 
         # Storage analysis
-        total_storage = sum(s.get('AllocatedStorage', 0) for s in snapshots)
-        total_estimated_cost = sum(s.get('EstimatedMonthlyCost', 0) for s in snapshots)
+        total_storage = sum(s.get("AllocatedStorage", 0) for s in snapshots)
+        total_estimated_cost = sum(s.get("EstimatedMonthlyCost", 0) for s in snapshots)
 
         # Encryption analysis
-        encrypted_snapshots = [s for s in snapshots if s.get('Encrypted', False)]
+        encrypted_snapshots = [s for s in snapshots if s.get("Encrypted", False)]
 
         return {
-            'total_snapshots': total_snapshots,
-            'unique_accounts': len(unique_accounts),
-            'unique_regions': len(unique_regions),
-            'unique_engines': len(unique_engines),
-            'account_ids': sorted(list(unique_accounts)),
-            'regions': sorted(list(unique_regions)),
-            'engines': sorted(list(unique_engines)),
-            'snapshot_types': {
-                'manual': len(manual_snapshots),
-                'automated': len(automated_snapshots),
-                'unknown': total_snapshots - len(manual_snapshots) - len(automated_snapshots)
+            "total_snapshots": total_snapshots,
+            "unique_accounts": len(unique_accounts),
+            "unique_regions": len(unique_regions),
+            "unique_engines": len(unique_engines),
+            "account_ids": sorted(list(unique_accounts)),
+            "regions": sorted(list(unique_regions)),
+            "engines": sorted(list(unique_engines)),
+            "snapshot_types": {
+                "manual": len(manual_snapshots),
+                "automated": len(automated_snapshots),
+                "unknown": total_snapshots - len(manual_snapshots) - len(automated_snapshots),
             },
-            'age_analysis': {
-                'aged_snapshots_90d': len(aged_snapshots),
-                'very_old_snapshots_180d': len(very_old_snapshots),
-                'cleanup_candidates': len([s for s in manual_snapshots if s.get('AgeDays', 0) >= 90])
+            "age_analysis": {
+                "aged_snapshots_90d": len(aged_snapshots),
+                "very_old_snapshots_180d": len(very_old_snapshots),
+                "cleanup_candidates": len([s for s in manual_snapshots if s.get("AgeDays", 0) >= 90]),
             },
-            'storage_analysis': {
-                'total_storage_gb': total_storage,
-                'estimated_monthly_cost': round(total_estimated_cost, 2),
-                'estimated_annual_cost': round(total_estimated_cost * 12, 2)
+            "storage_analysis": {
+                "total_storage_gb": total_storage,
+                "estimated_monthly_cost": round(total_estimated_cost, 2),
+                "estimated_annual_cost": round(total_estimated_cost * 12, 2),
             },
-            'security_analysis': {
-                'encrypted_snapshots': len(encrypted_snapshots),
-                'unencrypted_snapshots': total_snapshots - len(encrypted_snapshots),
-                'encryption_percentage': round((len(encrypted_snapshots) / total_snapshots) * 100, 1) if total_snapshots > 0 else 0
+            "security_analysis": {
+                "encrypted_snapshots": len(encrypted_snapshots),
+                "unencrypted_snapshots": total_snapshots - len(encrypted_snapshots),
+                "encryption_percentage": round((len(encrypted_snapshots) / total_snapshots) * 100, 1)
+                if total_snapshots > 0
+                else 0,
             },
-            'discovery_metrics': self.metrics
+            "discovery_metrics": self.metrics,
         }
 
-    def export_results(self, snapshots: List[Dict], output_file: str, format: str = 'csv') -> bool:
+    def export_results(self, snapshots: List[Dict], output_file: str, format: str = "csv") -> bool:
         """Export snapshot results to file"""
         try:
-            if format.lower() == 'csv':
+            if format.lower() == "csv":
                 import csv
 
                 if not snapshots:
@@ -546,22 +536,22 @@ class RDSSnapshotConfigAggregator:
 
                 fieldnames = sorted(list(all_keys))
 
-                with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
+                with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
                     writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
                     writer.writeheader()
                     for snapshot in snapshots:
                         # Convert complex objects to strings for CSV
                         row = {}
                         for key in fieldnames:
-                            value = snapshot.get(key, '')
+                            value = snapshot.get(key, "")
                             if isinstance(value, (list, dict)):
                                 row[key] = json.dumps(value)
                             else:
-                                row[key] = str(value) if value is not None else ''
+                                row[key] = str(value) if value is not None else ""
                         writer.writerow(row)
 
-            elif format.lower() == 'json':
-                with open(output_file, 'w', encoding='utf-8') as jsonfile:
+            elif format.lower() == "json":
+                with open(output_file, "w", encoding="utf-8") as jsonfile:
                     json.dump(snapshots, jsonfile, indent=2, default=str)
 
             else:
@@ -577,16 +567,16 @@ class RDSSnapshotConfigAggregator:
 
 
 @click.command()
-@click.option('--profile', help='AWS profile with Config aggregator access (overrides environment)')
-@click.option('--target-accounts', multiple=True, help='Specific account IDs to analyze')
-@click.option('--regions', multiple=True, help='Specific regions to check for aggregators')
-@click.option('--age-filter', type=int, help='Filter snapshots older than X days')
-@click.option('--snapshot-type', type=click.Choice(['manual', 'automated']), help='Filter by snapshot type')
-@click.option('--engine-filter', help='Filter by database engine (partial match)')
-@click.option('--output-file', default='./rds_snapshots_config_discovery.csv', help='Output file path')
-@click.option('--format', type=click.Choice(['csv', 'json']), default='csv', help='Output format')
-@click.option('--max-workers', type=int, default=10, help='Maximum concurrent workers')
-@click.option('--summary-only', is_flag=True, help='Show only summary report')
+@click.option("--profile", help="AWS profile with Config aggregator access (overrides environment)")
+@click.option("--target-accounts", multiple=True, help="Specific account IDs to analyze")
+@click.option("--regions", multiple=True, help="Specific regions to check for aggregators")
+@click.option("--age-filter", type=int, help="Filter snapshots older than X days")
+@click.option("--snapshot-type", type=click.Choice(["manual", "automated"]), help="Filter by snapshot type")
+@click.option("--engine-filter", help="Filter by database engine (partial match)")
+@click.option("--output-file", default="./rds_snapshots_config_discovery.csv", help="Output file path")
+@click.option("--format", type=click.Choice(["csv", "json"]), default="csv", help="Output format")
+@click.option("--max-workers", type=int, default=10, help="Maximum concurrent workers")
+@click.option("--summary-only", is_flag=True, help="Show only summary report")
 def discover_rds_snapshots(
     profile: str,
     target_accounts: Tuple[str],
@@ -597,7 +587,7 @@ def discover_rds_snapshots(
     output_file: str,
     format: str,
     max_workers: int,
-    summary_only: bool
+    summary_only: bool,
 ):
     """
     Enhanced RDS Snapshot Discovery via AWS Config Organization Aggregator
@@ -622,10 +612,7 @@ def discover_rds_snapshots(
         print_header("Enhanced RDS Snapshot Discovery via Config Aggregator", "v1.0")
 
         # Initialize discovery engine
-        aggregator = RDSSnapshotConfigAggregator(
-            management_profile=profile,
-            max_workers=max_workers
-        )
+        aggregator = RDSSnapshotConfigAggregator(management_profile=profile, max_workers=max_workers)
 
         # Override default regions if specified
         if regions:
@@ -658,7 +645,7 @@ def discover_rds_snapshots(
                 account_filter=target_account_list,
                 age_filter_days=age_filter,
                 snapshot_type_filter=snapshot_type,
-                engine_filter=engine_filter
+                engine_filter=engine_filter,
             )
 
         # Generate summary report
@@ -669,49 +656,46 @@ def discover_rds_snapshots(
 
         summary_table = create_table(
             title="RDS Snapshot Discovery Results",
-            columns=[
-                {"header": "Metric", "style": "cyan"},
-                {"header": "Value", "style": "green bold"}
-            ]
+            columns=[{"header": "Metric", "style": "cyan"}, {"header": "Value", "style": "green bold"}],
         )
 
-        summary_table.add_row("Total Snapshots", str(summary['total_snapshots']))
-        summary_table.add_row("Unique Accounts", str(summary['unique_accounts']))
-        summary_table.add_row("Unique Regions", str(summary['unique_regions']))
-        summary_table.add_row("Database Engines", str(summary['unique_engines']))
-        summary_table.add_row("Manual Snapshots", str(summary['snapshot_types']['manual']))
-        summary_table.add_row("Automated Snapshots", str(summary['snapshot_types']['automated']))
-        summary_table.add_row("Old Snapshots (90d+)", str(summary['age_analysis']['aged_snapshots_90d']))
-        summary_table.add_row("Cleanup Candidates", str(summary['age_analysis']['cleanup_candidates']))
-        summary_table.add_row("Total Storage (GB)", str(summary['storage_analysis']['total_storage_gb']))
-        summary_table.add_row("Est. Monthly Cost", format_cost(summary['storage_analysis']['estimated_monthly_cost']))
-        summary_table.add_row("Est. Annual Cost", format_cost(summary['storage_analysis']['estimated_annual_cost']))
-        summary_table.add_row("Encrypted Snapshots", f"{summary['security_analysis']['encrypted_snapshots']} ({summary['security_analysis']['encryption_percentage']}%)")
+        summary_table.add_row("Total Snapshots", str(summary["total_snapshots"]))
+        summary_table.add_row("Unique Accounts", str(summary["unique_accounts"]))
+        summary_table.add_row("Unique Regions", str(summary["unique_regions"]))
+        summary_table.add_row("Database Engines", str(summary["unique_engines"]))
+        summary_table.add_row("Manual Snapshots", str(summary["snapshot_types"]["manual"]))
+        summary_table.add_row("Automated Snapshots", str(summary["snapshot_types"]["automated"]))
+        summary_table.add_row("Old Snapshots (90d+)", str(summary["age_analysis"]["aged_snapshots_90d"]))
+        summary_table.add_row("Cleanup Candidates", str(summary["age_analysis"]["cleanup_candidates"]))
+        summary_table.add_row("Total Storage (GB)", str(summary["storage_analysis"]["total_storage_gb"]))
+        summary_table.add_row("Est. Monthly Cost", format_cost(summary["storage_analysis"]["estimated_monthly_cost"]))
+        summary_table.add_row("Est. Annual Cost", format_cost(summary["storage_analysis"]["estimated_annual_cost"]))
+        summary_table.add_row(
+            "Encrypted Snapshots",
+            f"{summary['security_analysis']['encrypted_snapshots']} ({summary['security_analysis']['encryption_percentage']}%)",
+        )
 
         console.print(summary_table)
 
         # Discovery metrics
         metrics_table = create_table(
             title="Discovery Performance Metrics",
-            columns=[
-                {"header": "Metric", "style": "blue"},
-                {"header": "Count", "style": "yellow"}
-            ]
+            columns=[{"header": "Metric", "style": "blue"}, {"header": "Count", "style": "yellow"}],
         )
 
-        metrics = summary['discovery_metrics']
-        metrics_table.add_row("Config Aggregators Found", str(metrics['aggregators_found']))
-        metrics_table.add_row("Regions Scanned", str(metrics['regions_scanned']))
-        metrics_table.add_row("API Calls Made", str(metrics['api_calls_made']))
-        metrics_table.add_row("Errors Encountered", str(metrics['errors_encountered']))
+        metrics = summary["discovery_metrics"]
+        metrics_table.add_row("Config Aggregators Found", str(metrics["aggregators_found"]))
+        metrics_table.add_row("Regions Scanned", str(metrics["regions_scanned"]))
+        metrics_table.add_row("API Calls Made", str(metrics["api_calls_made"]))
+        metrics_table.add_row("Errors Encountered", str(metrics["errors_encountered"]))
 
         console.print(metrics_table)
 
         # Account details
-        if summary['account_ids'] and len(summary['account_ids']) <= 20:  # Don't flood output
+        if summary["account_ids"] and len(summary["account_ids"]) <= 20:  # Don't flood output
             console.print(f"\n[cyan]📋 Accounts with RDS snapshots:[/cyan]")
-            for account_id in summary['account_ids']:
-                account_snapshots = [s for s in snapshots if s.get('AccountId') == account_id]
+            for account_id in summary["account_ids"]:
+                account_snapshots = [s for s in snapshots if s.get("AccountId") == account_id]
                 console.print(f"  [green]•[/green] {account_id}: {len(account_snapshots)} snapshots")
 
         # Export results unless summary-only
@@ -724,13 +708,13 @@ def discover_rds_snapshots(
         for region, aggregators in aggregator_map.items():
             console.print(f"  [blue]•[/blue] {region}: {', '.join(aggregators)}")
 
-        if summary['age_analysis']['cleanup_candidates'] > 0:
+        if summary["age_analysis"]["cleanup_candidates"] > 0:
             print_warning(
                 f"🎯 Found {summary['age_analysis']['cleanup_candidates']} manual snapshots "
                 f"older than 90 days - consider cleanup for cost optimization"
             )
 
-        if summary['security_analysis']['unencrypted_snapshots'] > 0:
+        if summary["security_analysis"]["unencrypted_snapshots"] > 0:
             print_warning(
                 f"🔒 Found {summary['security_analysis']['unencrypted_snapshots']} unencrypted snapshots "
                 f"- review for security compliance"
@@ -742,4 +726,4 @@ def discover_rds_snapshots(
 
 
 if __name__ == "__main__":
-    discover_rds_snapshots()
+    discover_rds_snapshots()