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

runbooks/finops/markdown_exporter.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Rich-styled Markdown Export Module for CloudOps Runbooks FinOps
+Rich-styled Markdown Export Module for CloudOps & FinOps Runbooks
 
 This module provides Rich table to markdown conversion functionality with
 MkDocs compatibility for copy-pasteable documentation tables.
@@ -27,7 +27,6 @@ from rich.table import Table
 from rich.text import Text
 
 from runbooks import __version__
-
 from runbooks.common.rich_utils import (
     STATUS_INDICATORS,
     console,
@@ -241,7 +240,7 @@ class MarkdownExporter:
 | Untagged Resources | {profile_data.get("untagged_resources", 0)} | N/A | Implement tagging strategy |
 
 ---
-*Generated by CloudOps Runbooks FinOps Module v{__version__}*
+*Generated by CloudOps & FinOps Runbooks Module v{__version__}*
 """
 
         return markdown_content
@@ -329,7 +328,7 @@ class MarkdownExporter:
 4. **Governance**: Tag {sum(p.get("untagged_resources", 0) for p in multi_profile_data)} untagged resources
 
 ---
-*Generated by CloudOps Runbooks FinOps Module v{__version__}*
+*Generated by CloudOps & FinOps Runbooks Module v{__version__}*
 """
 
         return markdown_content
@@ -400,14 +399,131 @@ class MarkdownExporter:
             return "❓ Unknown"
 
     def _calculate_mom_change(self, profiles: List[Dict[str, Any]]) -> float:
-        """Calculate month-over-month change percentage."""
-        total_current = sum(p.get("total_cost", 0) for p in profiles)
-        total_last = sum(p.get("last_month_cost", 0) for p in profiles)
+        """
+        Calculate month-over-month change percentage with smart partial month normalization.
+
+        Features:
+        - Detects partial months and applies normalization
+        - Handles equal-day vs full-month comparisons intelligently
+        - Integrates with existing period metadata infrastructure
+        - Rich CLI formatting for transparency
+        """
+        try:
+            from datetime import date, timedelta
+
+            from ..common.rich_utils import console
+
+            total_current = sum(p.get("total_cost", 0) for p in profiles)
+            total_last = sum(p.get("last_month_cost", 0) for p in profiles)
+
+            if total_last == 0:
+                return 0.0
+
+            # Check for period metadata in profiles to detect partial month scenarios
+            period_metadata = None
+            for profile in profiles:
+                if "period_metadata" in profile and profile["period_metadata"]:
+                    period_metadata = profile["period_metadata"]
+                    break
+
+            # Calculate raw percentage change
+            raw_change = ((total_current - total_last) / total_last) * 100
+
+            # If no period metadata available, return raw calculation
+            if not period_metadata:
+                return raw_change
+
+            # Extract period information
+            current_days = period_metadata.get("current_days", 0)
+            previous_days = period_metadata.get("previous_days", 0)
+            alignment_strategy = period_metadata.get("period_alignment_strategy", "standard")
+            is_partial_comparison = period_metadata.get("is_partial_comparison", False)
+            comparison_type = period_metadata.get("comparison_type", "standard_month_comparison")
+
+            # Apply smart normalization based on period alignment strategy
+            if alignment_strategy == "equal_days" and current_days > 0 and previous_days > 0:
+                # Equal-day comparison - use raw calculation (already normalized)
+                normalized_change = raw_change
+                console.log(
+                    f"[dim cyan]📊 MoM calculation: equal-day comparison ({current_days} vs {previous_days} days) - no adjustment needed[/]"
+                )
+
+            elif is_partial_comparison and current_days > 0 and previous_days > 0:
+                # Partial month vs full month - apply normalization factor
+                if current_days < previous_days:
+                    # Current month is partial, previous is full - normalize previous month
+                    normalization_factor = current_days / previous_days
+                    adjusted_last_cost = total_last * normalization_factor
+                    normalized_change = (
+                        ((total_current - adjusted_last_cost) / adjusted_last_cost) * 100
+                        if adjusted_last_cost > 0
+                        else 0.0
+                    )
+
+                    console.log(
+                        f"[yellow]⚡ MoM normalization: partial current month ({current_days} days) vs full previous ({previous_days} days)[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   Normalized factor: {normalization_factor:.2f} (adjusted previous: ${adjusted_last_cost:,.2f})[/]"
+                    )
+
+                elif current_days > previous_days:
+                    # Previous month is partial, current is full - normalize current month
+                    normalization_factor = previous_days / current_days
+                    adjusted_current_cost = total_current * normalization_factor
+                    normalized_change = (
+                        ((adjusted_current_cost - total_last) / total_last) * 100 if total_last > 0 else 0.0
+                    )
+
+                    console.log(
+                        f"[yellow]⚡ MoM normalization: full current month ({current_days} days) vs partial previous ({previous_days} days)[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   Normalized factor: {normalization_factor:.2f} (adjusted current: ${adjusted_current_cost:,.2f})[/]"
+                    )
+                else:
+                    # Equal days but marked as partial comparison - use raw calculation
+                    normalized_change = raw_change
+                    console.log(
+                        f"[cyan]📊 MoM calculation: equal periods ({current_days} days) - using standard calculation[/]"
+                    )
+            else:
+                # Standard monthly comparison - use raw calculation
+                normalized_change = raw_change
+                console.log(f"[dim cyan]📊 MoM calculation: standard monthly comparison - no normalization applied[/]")
+
+            # Detect and warn about extreme changes that might indicate data issues
+            if abs(normalized_change) > 200:  # >200% change
+                today = date.today()
+                days_into_month = today.day
+
+                if days_into_month <= 5:  # Early in month
+                    console.log(
+                        f"[yellow]⚠️  Large MoM change ({normalized_change:.1f}%) detected in early month (day {days_into_month})[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   This may be due to limited current month data - consider weekly analysis for accuracy[/]"
+                    )
+                elif comparison_type == "standard_month_comparison" and is_partial_comparison:
+                    console.log(
+                        f"[yellow]⚠️  Large MoM change ({normalized_change:.1f}%) with unequal periods detected[/]"
+                    )
+                    console.log(
+                        f"[dim yellow]   Consider using equal-day comparison for more accurate trend analysis[/]"
+                    )
+
+            return normalized_change
+
+        except Exception as e:
+            # Fallback to simple calculation if enhancement fails
+            console.log(f"[red]⚠️  MoM calculation enhancement failed: {str(e)}, using fallback calculation[/]")
+            total_current = sum(p.get("total_cost", 0) for p in profiles)
+            total_last = sum(p.get("last_month_cost", 0) for p in profiles)
 
-        if total_last == 0:
-            return 0.0
+            if total_last == 0:
+                return 0.0
 
-        return ((total_current - total_last) / total_last) * 100
+            return ((total_current - total_last) / total_last) * 100
 
     def _get_highest_cost_account(self, profiles: List[Dict[str, Any]]) -> str:
         """Get the account with highest cost."""
@@ -428,25 +544,38 @@ class MarkdownExporter:
     def format_vpc_cleanup_table(self, vpc_candidates: List[Any]) -> str:
         """
         Format VPC cleanup candidates into 15-column markdown table.
-        
+
         Args:
             vpc_candidates: List of VPCCandidate objects from vpc.unified_scenarios
-            
+
         Returns:
             Markdown formatted table string with VPC cleanup analysis
         """
         if not vpc_candidates:
             return "⚠️ No VPC candidates to format"
-        
+
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
-        
+
         # Build table header and separator
         headers = [
-            "Account_ID", "VPC_ID", "VPC_Name", "CIDR_Block", "Overlapping", 
-            "Is_Default", "ENI_Count", "Tags", "Flow_Logs", "TGW/Peering", 
-            "LBs_Present", "IaC", "Timeline", "Decision", "Owners/Approvals", "Notes"
+            "Account_ID",
+            "VPC_ID",
+            "VPC_Name",
+            "CIDR_Block",
+            "Overlapping",
+            "Is_Default",
+            "ENI_Count",
+            "Tags",
+            "Flow_Logs",
+            "TGW/Peering",
+            "LBs_Present",
+            "IaC",
+            "Timeline",
+            "Decision",
+            "Owners/Approvals",
+            "Notes",
         ]
-        
+
         markdown_lines = [
             "# VPC Cleanup Analysis Report",
             "",
@@ -457,82 +586,91 @@ class MarkdownExporter:
             "## VPC Cleanup Decision Table",
             "",
             "| " + " | ".join(headers) + " |",
-            "| " + " | ".join(["---" for _ in headers]) + " |"
+            "| " + " | ".join(["---" for _ in headers]) + " |",
         ]
-        
+
         # Process each VPC candidate with enhanced data extraction
         for candidate in vpc_candidates:
             # Extract data with safe attribute access and formatting
-            account_id = getattr(candidate, 'account_id', 'Unknown')
-            vpc_id = getattr(candidate, 'vpc_id', 'Unknown')
-            vpc_name = getattr(candidate, 'vpc_name', '') or 'Unnamed'
-            cidr_block = getattr(candidate, 'cidr_block', 'Unknown')
-            
+            account_id = getattr(candidate, "account_id", "Unknown")
+            vpc_id = getattr(candidate, "vpc_id", "Unknown")
+            vpc_name = getattr(candidate, "vpc_name", "") or "Unnamed"
+            cidr_block = getattr(candidate, "cidr_block", "Unknown")
+
             # Handle overlapping logic - check CIDR conflicts
             overlapping = self._check_cidr_overlapping(cidr_block, vpc_candidates)
-            
+
             # Enhanced is_default handling
-            is_default = getattr(candidate, 'is_default', False)
+            is_default = getattr(candidate, "is_default", False)
             is_default_display = "⚠️ Yes" if is_default else "No"
-            
+
             # Enhanced ENI count
-            dependency_analysis = getattr(candidate, 'dependency_analysis', None)
+            dependency_analysis = getattr(candidate, "dependency_analysis", None)
             eni_count = dependency_analysis.eni_count if dependency_analysis else 0
-            
+
             # Enhanced tags with owner focus
-            tags_dict = getattr(candidate, 'tags', {}) or {}
+            tags_dict = getattr(candidate, "tags", {}) or {}
             tags_display = self._format_tags_for_owners_display(tags_dict)
-            
+
             # Flow logs detection
             flow_logs = self._detect_flow_logs(candidate)
-            
+
             # TGW/Peering detection
             tgw_peering = self._detect_tgw_peering(candidate)
-            
+
             # Load balancers detection
             lbs_present = self._detect_load_balancers(candidate)
-            
+
             # IaC detection from tags
             iac_detected = self._detect_iac_from_tags(tags_dict)
-            
+
             # Timeline estimation based on VPC state
             timeline = self._estimate_cleanup_timeline(candidate)
-            
+
             # Decision based on bucket classification
             decision = self._determine_cleanup_decision(candidate)
-            
+
             # Enhanced owners/approvals extraction
             owners_approvals = self._extract_owners_approvals(tags_dict, is_default)
-            
+
             # Notes based on VPC characteristics
             notes = self._generate_vpc_notes(candidate)
-            overlapping = "Yes" if getattr(candidate, 'overlapping', False) else "No"
-            
+            overlapping = "Yes" if getattr(candidate, "overlapping", False) else "No"
+
             # Format boolean indicators with emoji
-            is_default = "⚠️ Yes" if getattr(candidate, 'is_default', False) else "✅ No"
-            flow_logs = "✅ Yes" if getattr(candidate, 'flow_logs_enabled', False) else "❌ No"
-            tgw_peering = "✅ Yes" if getattr(candidate, 'tgw_peering_attached', False) else "❌ No"
-            load_balancers = "✅ Yes" if getattr(candidate, 'load_balancers_present', False) else "❌ No"
-            iac_managed = "✅ Yes" if getattr(candidate, 'iac_managed', False) else "❌ No"
-            
+            is_default = "⚠️ Yes" if getattr(candidate, "is_default", False) else "✅ No"
+            flow_logs = "✅ Yes" if getattr(candidate, "flow_logs_enabled", False) else "❌ No"
+            tgw_peering = "✅ Yes" if getattr(candidate, "tgw_peering_attached", False) else "❌ No"
+            load_balancers = "✅ Yes" if getattr(candidate, "load_balancers_present", False) else "❌ No"
+            iac_managed = "✅ Yes" if getattr(candidate, "iac_managed", False) else "❌ No"
+
             # ENI Count handling
-            eni_count = getattr(candidate, 'eni_count', 0)
-            
+            eni_count = getattr(candidate, "eni_count", 0)
+
             # Tags formatting - prioritize important tags with enhanced display
-            tags = getattr(candidate, 'tags', {}) or {}
+            tags = getattr(candidate, "tags", {}) or {}
             relevant_tags = []
             if tags:
                 # Priority order for business-relevant tags
-                priority_keys = ['Name', 'Environment', 'Project', 'Owner', 'BusinessOwner', 'Team', 'CostCenter', 'Application']
+                priority_keys = [
+                    "Name",
+                    "Environment",
+                    "Project",
+                    "Owner",
+                    "BusinessOwner",
+                    "Team",
+                    "CostCenter",
+                    "Application",
+                ]
                 for key in priority_keys:
                     if key in tags and tags[key] and len(relevant_tags) < 3:  # Increased limit for better visibility
                         relevant_tags.append(f"{key}:{tags[key]}")
-                
+
                 # Add other important tags if space available
                 for key, value in tags.items():
                     if key not in priority_keys and value and len(relevant_tags) < 3:
                         relevant_tags.append(f"{key}:{value}")
-            
+
             # Enhanced display logic for tags
             if relevant_tags:
                 tags_display = "; ".join(relevant_tags)
@@ -544,146 +682,167 @@ class MarkdownExporter:
             else:
                 # No tags at all
                 tags_display = "No tags"
-            
+
             # Timeline and Decision
-            timeline = getattr(candidate, 'cleanup_timeline', '') or getattr(candidate, 'implementation_timeline', 'Unknown')
-            
+            timeline = getattr(candidate, "cleanup_timeline", "") or getattr(
+                candidate, "implementation_timeline", "Unknown"
+            )
+
             # Decision handling - check for different decision attribute names
-            decision_attr = getattr(candidate, 'decision', None)
+            decision_attr = getattr(candidate, "decision", None)
             if decision_attr:
-                if hasattr(decision_attr, 'value'):
+                if hasattr(decision_attr, "value"):
                     decision = decision_attr.value
                 else:
                     decision = str(decision_attr)
             else:
                 # Fallback decision logic based on risk/dependencies
-                decision = getattr(candidate, 'cleanup_bucket', 'Unknown')
-            
+                decision = getattr(candidate, "cleanup_bucket", "Unknown")
+
             # Owners/Approvals - Enhanced extraction from tags if not populated
-            owners = getattr(candidate, 'owners_approvals', []) or getattr(candidate, 'stakeholders', [])
-            
+            owners = getattr(candidate, "owners_approvals", []) or getattr(candidate, "stakeholders", [])
+
             # If no owners found via attributes, try to extract from tags directly
             if not owners and tags:
-                owner_keys = ['Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact', 'CreatedBy', 'ManagedBy']
+                owner_keys = ["Owner", "BusinessOwner", "TechnicalOwner", "Team", "Contact", "CreatedBy", "ManagedBy"]
                 for key in owner_keys:
                     if key in tags and tags[key]:
-                        if 'business' in key.lower() or 'manager' in tags[key].lower():
+                        if "business" in key.lower() or "manager" in tags[key].lower():
                             owners.append(f"{tags[key]} (Business)")
-                        elif 'technical' in key.lower() or any(tech in tags[key].lower() for tech in ['ops', 'devops', 'engineering']):
+                        elif "technical" in key.lower() or any(
+                            tech in tags[key].lower() for tech in ["ops", "devops", "engineering"]
+                        ):
                             owners.append(f"{tags[key]} (Technical)")
                         else:
                             owners.append(tags[key])
                         break  # Take first found owner to avoid clutter
-            
+
             if owners:
                 owners_display = "; ".join(owners)
                 if len(owners_display) > 30:  # Increased width for better display
                     owners_display = owners_display[:27] + "..."
             else:
                 # Enhanced "unknown" display based on VPC characteristics
-                if getattr(candidate, 'is_default', False):
+                if getattr(candidate, "is_default", False):
                     owners_display = "System Default"
-                elif getattr(candidate, 'iac_detected', False):
+                elif getattr(candidate, "iac_detected", False):
                     owners_display = "IaC Managed"
                 else:
                     owners_display = "No owner tags"
-            
+
             # Notes - combination of risk assessment and business impact
             notes_parts = []
-            risk_level = getattr(candidate, 'risk_level', None)
+            risk_level = getattr(candidate, "risk_level", None)
             if risk_level:
-                risk_val = risk_level.value if hasattr(risk_level, 'value') else str(risk_level)
+                risk_val = risk_level.value if hasattr(risk_level, "value") else str(risk_level)
                 notes_parts.append(f"Risk:{risk_val}")
-            
-            business_impact = getattr(candidate, 'business_impact', '') 
+
+            business_impact = getattr(candidate, "business_impact", "")
             if business_impact:
                 notes_parts.append(business_impact[:15])  # Truncate
-            
-            notes = "; ".join(notes_parts) if notes_parts else getattr(candidate, 'notes', 'No notes')
+
+            notes = "; ".join(notes_parts) if notes_parts else getattr(candidate, "notes", "No notes")
             if len(notes) > 30:  # Truncate for table formatting
                 notes = notes[:27] + "..."
-            
+
             # Create table row - escape pipes for markdown compatibility
             row_data = [
-                account_id, vpc_id, vpc_name, cidr_block, overlapping,
-                is_default, str(eni_count), tags_display, flow_logs, tgw_peering,
-                load_balancers, iac_managed, timeline, decision, owners_display, notes
+                account_id,
+                vpc_id,
+                vpc_name,
+                cidr_block,
+                overlapping,
+                is_default,
+                str(eni_count),
+                tags_display,
+                flow_logs,
+                tgw_peering,
+                load_balancers,
+                iac_managed,
+                timeline,
+                decision,
+                owners_display,
+                notes,
             ]
-            
+
             # Escape pipes and format row
             escaped_data = [str(cell).replace("|", "\\|") for cell in row_data]
             markdown_lines.append("| " + " | ".join(escaped_data) + " |")
-        
+
         # Add summary statistics
         total_vpcs = len(vpc_candidates)
-        default_vpcs = sum(1 for c in vpc_candidates if getattr(c, 'is_default', False))
-        flow_logs_enabled = sum(1 for c in vpc_candidates if getattr(c, 'flow_logs_enabled', False))
-        iac_managed_count = sum(1 for c in vpc_candidates if getattr(c, 'iac_managed', False))
-        zero_eni_vpcs = sum(1 for c in vpc_candidates if getattr(c, 'eni_count', 1) == 0)
-        
-        markdown_lines.extend([
-            "",
-            "## Analysis Summary",
-            "",
-            f"- **Total VPCs Analyzed**: {total_vpcs}",
-            f"- **Default VPCs**: {default_vpcs} ({(default_vpcs/total_vpcs*100):.1f}%)",
-            f"- **Flow Logs Enabled**: {flow_logs_enabled} ({(flow_logs_enabled/total_vpcs*100):.1f}%)",
-            f"- **IaC Managed**: {iac_managed_count} ({(iac_managed_count/total_vpcs*100):.1f}%)",
-            f"- **Zero ENI Attachments**: {zero_eni_vpcs} ({(zero_eni_vpcs/total_vpcs*100):.1f}%)",
-            "",
-            "## Cleanup Recommendations",
-            "",
-            "1. **Priority 1**: VPCs with zero ENI attachments and no dependencies",
-            "2. **Priority 2**: Default VPCs with no active resources",
-            "3. **Priority 3**: Non-IaC managed VPCs requiring manual cleanup",
-            "4. **Review Required**: VPCs with unclear ownership or business impact",
-            "",
-            "---",
-            f"*Generated by CloudOps Runbooks VPC Module latest version at {timestamp}*"
-        ])
-        
+        default_vpcs = sum(1 for c in vpc_candidates if getattr(c, "is_default", False))
+        flow_logs_enabled = sum(1 for c in vpc_candidates if getattr(c, "flow_logs_enabled", False))
+        iac_managed_count = sum(1 for c in vpc_candidates if getattr(c, "iac_managed", False))
+        zero_eni_vpcs = sum(1 for c in vpc_candidates if getattr(c, "eni_count", 1) == 0)
+
+        markdown_lines.extend(
+            [
+                "",
+                "## Analysis Summary",
+                "",
+                f"- **Total VPCs Analyzed**: {total_vpcs}",
+                f"- **Default VPCs**: {default_vpcs} ({(default_vpcs / total_vpcs * 100):.1f}%)",
+                f"- **Flow Logs Enabled**: {flow_logs_enabled} ({(flow_logs_enabled / total_vpcs * 100):.1f}%)",
+                f"- **IaC Managed**: {iac_managed_count} ({(iac_managed_count / total_vpcs * 100):.1f}%)",
+                f"- **Zero ENI Attachments**: {zero_eni_vpcs} ({(zero_eni_vpcs / total_vpcs * 100):.1f}%)",
+                "",
+                "## Cleanup Recommendations",
+                "",
+                "1. **Priority 1**: VPCs with zero ENI attachments and no dependencies",
+                "2. **Priority 2**: Default VPCs with no active resources",
+                "3. **Priority 3**: Non-IaC managed VPCs requiring manual cleanup",
+                "4. **Review Required**: VPCs with unclear ownership or business impact",
+                "",
+                "---",
+                f"*Generated by CloudOps Runbooks VPC Module latest version at {timestamp}*",
+            ]
+        )
+
         return "\n".join(markdown_lines)
 
-    def export_vpc_analysis_to_file(self, vpc_candidates: List[Any], filename: str = None, output_dir: str = "./exports") -> str:
+    def export_vpc_analysis_to_file(
+        self, vpc_candidates: List[Any], filename: str = None, output_dir: str = "./exports"
+    ) -> str:
         """
         Export VPC analysis to markdown file with intelligent naming.
-        
+
         Args:
             vpc_candidates: List of VPC candidates from analysis
             filename: Base filename (optional, auto-generated if not provided)
             output_dir: Output directory path
-            
+
         Returns:
             Path to exported file
         """
         if not filename:
             timestamp = datetime.now().strftime("%Y-%m-%d")
             filename = f"vpc-cleanup-analysis-{timestamp}.md"
-        
+
         # Ensure .md extension
-        if not filename.endswith('.md'):
+        if not filename.endswith(".md"):
             filename = f"{filename}.md"
-        
+
         # Create output directory
         output_path = Path(output_dir)
         output_path.mkdir(parents=True, exist_ok=True)
-        
+
         # Generate markdown content
         markdown_content = self.format_vpc_cleanup_table(vpc_candidates)
-        
+
         # Write to file
         filepath = output_path / filename
-        
+
         print_info(f"📝 Exporting VPC analysis to: {filename}")
-        
+
         try:
             with open(filepath, "w", encoding="utf-8") as f:
                 f.write(markdown_content)
-            
+
             print_success(f"✅ VPC analysis exported: {filepath}")
             print_info(f"🔗 Ready for executive review or documentation systems")
             return str(filepath)
-            
+
         except Exception as e:
             print_warning(f"❌ Failed to export VPC analysis: {e}")
             return ""
@@ -692,26 +851,30 @@ class MarkdownExporter:
         """Check for CIDR block overlapping across VPCs."""
         if not cidr_block or not vpc_candidates:
             return "No"
-        
+
         # Simple overlapping check - in enterprise scenario, this would use more sophisticated logic
         current_cidr = cidr_block
         for candidate in vpc_candidates:
-            other_cidr = getattr(candidate, 'cidr_block', None)
-            if other_cidr and other_cidr != current_cidr and current_cidr.startswith(other_cidr.split('/')[0].rsplit('.', 1)[0]):
+            other_cidr = getattr(candidate, "cidr_block", None)
+            if (
+                other_cidr
+                and other_cidr != current_cidr
+                and current_cidr.startswith(other_cidr.split("/")[0].rsplit(".", 1)[0])
+            ):
                 return "Yes"
-        
+
         return "No"
 
     def _detect_flow_logs(self, candidate: Any) -> str:
         """Detect if VPC has flow logs enabled."""
-        return "Yes" if getattr(candidate, 'flow_logs_enabled', False) else "No"
+        return "Yes" if getattr(candidate, "flow_logs_enabled", False) else "No"
 
     def _detect_tgw_peering(self, candidate: Any) -> str:
         """Analyze Transit Gateway and VPC peering connections."""
         # Check for TGW attachments and peering connections
-        tgw_attachments = getattr(candidate, 'tgw_attachments', []) or []
-        peering_connections = getattr(candidate, 'peering_connections', []) or []
-        
+        tgw_attachments = getattr(candidate, "tgw_attachments", []) or []
+        peering_connections = getattr(candidate, "peering_connections", []) or []
+
         if tgw_attachments or peering_connections:
             connection_count = len(tgw_attachments) + len(peering_connections)
             return f"Yes ({connection_count})"
@@ -719,12 +882,12 @@ class MarkdownExporter:
 
     def _detect_load_balancers(self, candidate: Any) -> str:
         """Detect load balancers in the VPC."""
-        load_balancers = getattr(candidate, 'load_balancers', []) or []
+        load_balancers = getattr(candidate, "load_balancers", []) or []
         return "Yes" if load_balancers else "No"
 
     def _detect_iac_from_tags(self, tags_dict: dict) -> str:
         """Detect Infrastructure as Code management from tags."""
-        iac_keys = ['aws:cloudformation:stack-name', 'terraform:module', 'cdktf:stack', 'pulumi:project']
+        iac_keys = ["aws:cloudformation:stack-name", "terraform:module", "cdktf:stack", "pulumi:project"]
         for key in iac_keys:
             if key in tags_dict and tags_dict[key]:
                 return "Yes"
@@ -733,26 +896,26 @@ class MarkdownExporter:
     def _estimate_cleanup_timeline(self, candidate: Any) -> str:
         """Estimate cleanup timeline based on complexity."""
         # Simple heuristic based on dependencies
-        if hasattr(candidate, 'dependency_analysis') and candidate.dependency_analysis:
-            eni_count = getattr(candidate.dependency_analysis, 'eni_count', 0)
+        if hasattr(candidate, "dependency_analysis") and candidate.dependency_analysis:
+            eni_count = getattr(candidate.dependency_analysis, "eni_count", 0)
         else:
             eni_count = 0
-            
+
         if eni_count == 0:
             return "1-2 days"
         elif eni_count < 5:
-            return "3-5 days" 
+            return "3-5 days"
         else:
             return "1-2 weeks"
 
     def _format_cleanup_decision(self, candidate: Any) -> str:
         """Format cleanup decision recommendation."""
-        recommendation = getattr(candidate, 'cleanup_recommendation', 'unknown')
-        if recommendation == 'delete':
+        recommendation = getattr(candidate, "cleanup_recommendation", "unknown")
+        if recommendation == "delete":
             return "Delete"
-        elif recommendation == 'keep':
+        elif recommendation == "keep":
             return "Keep"
-        elif recommendation == 'review':
+        elif recommendation == "review":
             return "Review"
         else:
             return "TBD"
@@ -761,35 +924,35 @@ class MarkdownExporter:
         """Format tags for display with priority on ownership information."""
         if not tags_dict:
             return "No tags"
-        
+
         # Priority keys focusing on ownership and approvals
-        priority_keys = ['Name', 'Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact']
+        priority_keys = ["Name", "Owner", "BusinessOwner", "TechnicalOwner", "Team", "Contact"]
         relevant_tags = []
-        
+
         for key in priority_keys:
             if key in tags_dict and tags_dict[key]:
                 relevant_tags.append(f"{key}:{tags_dict[key]}")
                 if len(relevant_tags) >= 3:  # Limit for table readability
                     break
-        
+
         return "; ".join(relevant_tags) if relevant_tags else f"({len(tags_dict)} tags)"
 
     def _determine_cleanup_decision(self, candidate: Any) -> str:
         """Determine cleanup decision based on VPC analysis."""
         # Check the cleanup bucket from three-bucket strategy
-        cleanup_bucket = getattr(candidate, 'cleanup_bucket', 'unknown')
-        
-        if cleanup_bucket == 'bucket_1':
+        cleanup_bucket = getattr(candidate, "cleanup_bucket", "unknown")
+
+        if cleanup_bucket == "bucket_1":
             return "Delete"
-        elif cleanup_bucket == 'bucket_2': 
+        elif cleanup_bucket == "bucket_2":
             return "Review"
-        elif cleanup_bucket == 'bucket_3':
+        elif cleanup_bucket == "bucket_3":
             return "Keep"
         else:
             # Fallback logic based on other attributes
-            is_default = getattr(candidate, 'is_default', False)
-            has_eni = getattr(candidate, 'eni_count', 0) > 0
-            
+            is_default = getattr(candidate, "is_default", False)
+            has_eni = getattr(candidate, "eni_count", 0) > 0
+
             if is_default and not has_eni:
                 return "Delete"
             elif has_eni:
@@ -800,33 +963,33 @@ class MarkdownExporter:
     def _extract_owners_approvals(self, tags_dict: dict, is_default: bool) -> str:
         """Extract owners and approval information from tags and VPC status."""
         # Extract from tags with enhanced owner detection
-        owner_keys = ['Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact', 'CreatedBy', 'ManagedBy']
-        
+        owner_keys = ["Owner", "BusinessOwner", "TechnicalOwner", "Team", "Contact", "CreatedBy", "ManagedBy"]
+
         extracted_owners = []
         for key in owner_keys:
             if key in tags_dict and tags_dict[key]:
                 value = tags_dict[key]
-                if 'business' in key.lower():
+                if "business" in key.lower():
                     extracted_owners.append(f"{value} (Business)")
-                elif 'technical' in key.lower():
+                elif "technical" in key.lower():
                     extracted_owners.append(f"{value} (Technical)")
-                elif 'team' in key.lower():
+                elif "team" in key.lower():
                     extracted_owners.append(f"{value} (Team)")
                 else:
                     extracted_owners.append(f"{value} ({key})")
-                
+
                 if len(extracted_owners) >= 2:  # Limit for table readability
                     break
-        
+
         if extracted_owners:
             return "; ".join(extracted_owners)
-        
+
         # Fallback based on VPC type
         if is_default:
             return "System Default VPC"
         else:
             # Check for IaC tags
-            iac_keys = ['aws:cloudformation:stack-name', 'terraform:module', 'cdktf:stack', 'pulumi:project']
+            iac_keys = ["aws:cloudformation:stack-name", "terraform:module", "cdktf:stack", "pulumi:project"]
             for key in iac_keys:
                 if key in tags_dict and tags_dict[key]:
                     return "IaC Managed"
@@ -835,35 +998,35 @@ class MarkdownExporter:
     def _generate_vpc_notes(self, candidate: Any) -> str:
         """Generate comprehensive notes for VPC candidate."""
         notes = []
-        
+
         # Add bucket classification note
-        cleanup_bucket = getattr(candidate, 'cleanup_bucket', 'unknown')
-        if cleanup_bucket == 'bucket_1':
+        cleanup_bucket = getattr(candidate, "cleanup_bucket", "unknown")
+        if cleanup_bucket == "bucket_1":
             notes.append("Internal data plane - safe for cleanup")
-        elif cleanup_bucket == 'bucket_2':
+        elif cleanup_bucket == "bucket_2":
             notes.append("External interconnects - requires analysis")
-        elif cleanup_bucket == 'bucket_3':
+        elif cleanup_bucket == "bucket_3":
             notes.append("Control plane - manual review required")
-            
+
         # Add ENI count if significant
-        if hasattr(candidate, 'dependency_analysis') and candidate.dependency_analysis:
-            eni_count = getattr(candidate.dependency_analysis, 'eni_count', 0)
+        if hasattr(candidate, "dependency_analysis") and candidate.dependency_analysis:
+            eni_count = getattr(candidate.dependency_analysis, "eni_count", 0)
             if eni_count > 0:
                 notes.append(f"{eni_count} ENI attachments")
-        
+
         # Add default VPC note
-        if getattr(candidate, 'is_default', False):
+        if getattr(candidate, "is_default", False):
             notes.append("Default VPC (CIS compliance issue)")
-            
+
         # Add IaC detection
-        if getattr(candidate, 'iac_detected', False):
+        if getattr(candidate, "iac_detected", False):
             notes.append("IaC managed")
-            
+
         # Add security concerns
-        risk_level = getattr(candidate, 'risk_level', 'unknown')
-        if risk_level == 'high':
+        risk_level = getattr(candidate, "risk_level", "unknown")
+        if risk_level == "high":
             notes.append("High security risk")
-            
+
         return "; ".join(notes) if notes else "Standard VPC cleanup candidate"