runbooks 0.9.8__py3-none-any.whl → 0.9.9__py3-none-any.whl

runbooks/__init__.py

@@ -61,7 +61,7 @@ s3_ops = S3Operations()
 
 # Centralized Version Management - Single Source of Truth
 # All modules MUST import __version__ from this location
-__version__ = "0.9.7"
+__version__ = "0.9.9"
 
 # Fallback for legacy importlib.metadata usage during transition
 try:

runbooks/common/rich_utils.py

@@ -132,6 +132,7 @@ def print_banner() -> None:
 
 def create_table(
     title: Optional[str] = None,
+    caption: Optional[str] = None,
     columns: List[Dict[str, Any]] = None,
     show_header: bool = True,
     show_footer: bool = False,
@@ -143,6 +144,7 @@ def create_table(
 
     Args:
         title: Table title
+        caption: Table caption (displayed below the table)
         columns: List of column definitions [{"name": "Col1", "style": "cyan", "justify": "left"}]
         show_header: Show header row
         show_footer: Show footer row
@@ -154,6 +156,7 @@ def create_table(
     """
     table = Table(
         title=title,
+        caption=caption,
         show_header=show_header,
         show_footer=show_footer,
         box=box_style,

runbooks/finops/markdown_exporter.py

@@ -423,6 +423,232 @@ class MarkdownExporter:
         highest = max(profiles, key=lambda p: p.get("potential_savings", 0))
         return highest.get("profile_name", "Unknown")[:20]
 
+    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"
+        ]
+        
+        markdown_lines = [
+            "# VPC Cleanup Analysis Report",
+            "",
+            f"**Generated**: {timestamp}",
+            f"**Total VPC Candidates**: {len(vpc_candidates)}",
+            f"**Analysis Source**: CloudOps Runbooks VPC Module v0.9.9",
+            "",
+            "## VPC Cleanup Decision Table",
+            "",
+            "| " + " | ".join(headers) + " |",
+            "| " + " | ".join(["---" for _ in headers]) + " |"
+        ]
+        
+        # Process each VPC candidate
+        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')
+            
+            # Handle overlapping logic - may need to calculate from CIDR analysis
+            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"
+            
+            # ENI Count handling
+            eni_count = getattr(candidate, 'eni_count', 0)
+            
+            # Tags formatting - prioritize important tags with enhanced display
+            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']
+                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)
+                if len(tags_display) > 35:  # Slightly increased width for better readability
+                    tags_display = tags_display[:32] + "..."
+            elif tags:
+                # If tags exist but none were priority, show count
+                tags_display = f"({len(tags)} tags)"
+            else:
+                # No tags at all
+                tags_display = "No tags"
+            
+            # Timeline and Decision
+            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)
+            if decision_attr:
+                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')
+            
+            # Owners/Approvals - Enhanced extraction from tags if not populated
+            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']
+                for key in owner_keys:
+                    if key in tags and tags[key]:
+                        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']):
+                            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):
+                    owners_display = "System Default"
+                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)
+            if 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', '') 
+            if business_impact:
+                notes_parts.append(business_impact[:15])  # Truncate
+            
+            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
+            ]
+            
+            # 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 v0.9.9 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:
+        """
+        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'):
+            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 ""
+
 
 def export_finops_to_markdown(
     profile_data: Union[Dict[str, Any], List[Dict[str, Any]]],

runbooks/finops/optimizer.py

@@ -11,6 +11,8 @@ from typing import Any, Dict, List, Optional
 
 import boto3
 
+from ..common.rich_utils import console
+
 
 @dataclass
 class CostSavingsOpportunity:

runbooks/finops/single_dashboard.py

@@ -638,7 +638,7 @@ class SingleAccountDashboard:
                 style="dim",
             )
 
-        console.print(table)
+        rich_console.print(table)
 
         # Summary panel (using filtered services for consistent analysis)
         total_current = sum(filtered_current_services.values())
@@ -681,7 +681,7 @@ class SingleAccountDashboard:
 • Services Analyzed: {len(all_services)}{period_info}
         """
 
-        console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
+        rich_console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
 
     def _export_service_analysis(
         self, args: argparse.Namespace, cost_data: Dict[str, Any], service_costs: List[str], account_id: str

runbooks/finops/vpc_cleanup_exporter.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+VPC Cleanup Exporter Module - Enterprise VPC Cleanup Result Export
+
+This module provides export functionality for VPC cleanup analysis results,
+leveraging the existing markdown_exporter infrastructure with VPC-specific formatting.
+
+Author: CloudOps Runbooks Team
+Version: 0.9.9
+"""
+
+import csv
+import json
+import os
+from datetime import datetime
+from typing import Any, Dict, List
+
+from .markdown_exporter import MarkdownExporter
+
+
+def _format_tags_for_display(tags_dict: Dict[str, str]) -> str:
+    """Format tags for display with priority order."""
+    if not tags_dict:
+        return "No tags"
+    
+    priority_keys = ['Name', 'Environment', 'Project', 'Owner', 'BusinessOwner', 'Team', 'CostCenter']
+    relevant_tags = []
+    
+    for key in priority_keys:
+        if key in tags_dict and tags_dict[key]:
+            relevant_tags.append(f"{key}:{tags_dict[key]}")
+    
+    # Add other important tags
+    for key, value in tags_dict.items():
+        if key not in priority_keys and value and len(relevant_tags) < 5:
+            relevant_tags.append(f"{key}:{value}")
+    
+    return "; ".join(relevant_tags) if relevant_tags else f"({len(tags_dict)} tags)"
+
+
+def export_vpc_cleanup_results(vpc_result: Any, export_formats: List[str], output_dir: str = "./") -> Dict[str, str]:
+    """
+    Export VPC cleanup results in multiple formats.
+    
+    Args:
+        vpc_result: VPC cleanup analysis result object
+        export_formats: List of formats to export (markdown, csv, json, pdf)
+        output_dir: Directory to save exported files
+        
+    Returns:
+        Dict mapping format to exported filename
+    """
+    results = {}
+    
+    # Extract VPC candidates from result - use correct attribute name
+    vpc_candidates = getattr(vpc_result, 'cleanup_candidates', [])
+    if not vpc_candidates:
+        # Fallback to other possible attribute names
+        vpc_candidates = getattr(vpc_result, 'vpc_candidates', [])
+    
+    if 'markdown' in export_formats:
+        try:
+            exporter = MarkdownExporter()
+            markdown_filename = exporter.export_vpc_analysis_to_file(
+                vpc_candidates,
+                filename="vpc-cleanup-candidates.md",
+                output_dir=output_dir
+            )
+            results['markdown'] = markdown_filename
+        except Exception as e:
+            print(f"Warning: Markdown export failed: {e}")
+            results['markdown'] = None
+    
+    # Real implementations for other formats
+    if 'csv' in export_formats:
+        try:
+            csv_filename = _export_vpc_candidates_csv(vpc_candidates, output_dir)
+            results['csv'] = csv_filename
+        except Exception as e:
+            print(f"Warning: CSV export failed: {e}")
+            results['csv'] = None
+            
+    if 'json' in export_formats:
+        try:
+            json_filename = _export_vpc_candidates_json(vpc_candidates, output_dir)
+            results['json'] = json_filename
+        except Exception as e:
+            print(f"Warning: JSON export failed: {e}")
+            results['json'] = None
+            
+    if 'pdf' in export_formats:
+        try:
+            pdf_filename = _export_vpc_candidates_pdf(vpc_candidates, output_dir)
+            results['pdf'] = pdf_filename
+        except Exception as e:
+            print(f"Warning: PDF export failed: {e}")
+            results['pdf'] = None
+    
+    return results
+
+
+def _export_vpc_candidates_csv(vpc_candidates: List[Any], output_dir: str) -> str:
+    """Export VPC candidates to CSV format with all 15 columns."""
+    filename = os.path.join(output_dir, "vpc-cleanup-candidates.csv")
+    
+    # 15-column headers for comprehensive VPC analysis
+    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"
+    ]
+    
+    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(headers)
+        
+        for candidate in vpc_candidates:
+            # Extract data with enhanced tag and owner handling
+            tags_dict = getattr(candidate, 'tags', {}) or {}
+            
+            # Enhanced tag display - prioritize important tags
+            if tags_dict:
+                priority_keys = ['Name', 'Environment', 'Project', 'Owner', 'BusinessOwner', 'Team']
+                relevant_tags = []
+                for key in priority_keys:
+                    if key in tags_dict and tags_dict[key]:
+                        relevant_tags.append(f"{key}:{tags_dict[key]}")
+                
+                # Add other important tags
+                for key, value in tags_dict.items():
+                    if key not in priority_keys and value and len(relevant_tags) < 5:
+                        relevant_tags.append(f"{key}:{value}")
+                
+                tags_str = "; ".join(relevant_tags)
+            else:
+                tags_str = "No tags"
+            
+            load_balancers = getattr(candidate, 'load_balancers', []) or []
+            lbs_present = "Yes" if load_balancers else "No"
+            
+            # Enhanced owner extraction
+            owners = getattr(candidate, 'owners_approvals', []) or []
+            
+            # If no owners found via attributes, extract from tags directly
+            if not owners and tags_dict:
+                owner_keys = ['Owner', 'BusinessOwner', 'TechnicalOwner', 'Team', 'Contact', 'CreatedBy', 'ManagedBy']
+                for key in owner_keys:
+                    if key in tags_dict and tags_dict[key]:
+                        if 'business' in key.lower() or 'manager' in tags_dict[key].lower():
+                            owners.append(f"{tags_dict[key]} (Business)")
+                        elif 'technical' in key.lower() or any(tech in tags_dict[key].lower() for tech in ['ops', 'devops', 'engineering']):
+                            owners.append(f"{tags_dict[key]} (Technical)")
+                        else:
+                            owners.append(tags_dict[key])
+            
+            if owners:
+                owners_str = "; ".join(owners)
+            else:
+                # Enhanced fallback for CSV
+                if getattr(candidate, 'is_default', False):
+                    owners_str = "System Default VPC"
+                elif getattr(candidate, 'iac_detected', False):
+                    owners_str = "IaC Managed"
+                else:
+                    owners_str = "No owner tags found"
+            
+            row = [
+                getattr(candidate, 'account_id', 'Unknown'),
+                getattr(candidate, 'vpc_id', ''),
+                getattr(candidate, 'vpc_name', 'Unnamed'),
+                getattr(candidate, 'cidr_block', ''),
+                "No",  # Overlapping analysis would need CIDR comparison
+                "Yes" if getattr(candidate, 'is_default', False) else "No",
+                getattr(candidate, 'dependency_analysis', {}).eni_count if hasattr(candidate, 'dependency_analysis') else 0,
+                tags_str,
+                "Yes" if getattr(candidate, 'flow_logs_enabled', False) else "No",
+                "No",  # TGW/Peering analysis placeholder
+                lbs_present,
+                "Yes" if getattr(candidate, 'iac_detected', False) else "No",
+                "Unknown",  # Timeline analysis placeholder
+                getattr(candidate, 'cleanup_recommendation', 'unknown'),
+                owners_str,
+                "Generated by CloudOps Runbooks VPC Module"
+            ]
+            writer.writerow(row)
+    
+    return filename
+
+
+def _export_vpc_candidates_json(vpc_candidates: List[Any], output_dir: str) -> str:
+    """Export VPC candidates to JSON format with full data structure."""
+    filename = os.path.join(output_dir, "vpc-cleanup-candidates.json")
+    
+    # Convert candidates to serializable format
+    candidates_data = []
+    for candidate in vpc_candidates:
+        candidate_dict = {
+            "account_id": getattr(candidate, 'account_id', 'Unknown'),
+            "vpc_id": getattr(candidate, 'vpc_id', ''),
+            "vpc_name": getattr(candidate, 'vpc_name', 'Unnamed'),
+            "cidr_block": getattr(candidate, 'cidr_block', ''),
+            "region": getattr(candidate, 'region', 'unknown'),
+            "is_default": getattr(candidate, 'is_default', False),
+            "state": getattr(candidate, 'state', 'unknown'),
+            "tags": getattr(candidate, 'tags', {}) or {},
+            "tags_summary": _format_tags_for_display(getattr(candidate, 'tags', {}) or {}),
+            "flow_logs_enabled": getattr(candidate, 'flow_logs_enabled', False),
+            "load_balancers": getattr(candidate, 'load_balancers', []) or [],
+            "iac_detected": getattr(candidate, 'iac_detected', False),
+            "owners_approvals": getattr(candidate, 'owners_approvals', []) or [],
+            "cleanup_bucket": getattr(candidate, 'cleanup_bucket', 'unknown'),
+            "cleanup_recommendation": getattr(candidate, 'cleanup_recommendation', 'unknown'),
+            "risk_assessment": getattr(candidate, 'risk_assessment', 'unknown'),
+            "business_impact": getattr(candidate, 'business_impact', 'unknown')
+        }
+        
+        # Add dependency analysis if available
+        if hasattr(candidate, 'dependency_analysis') and candidate.dependency_analysis:
+            dep_analysis = candidate.dependency_analysis
+            candidate_dict["dependency_analysis"] = {
+                "eni_count": getattr(dep_analysis, 'eni_count', 0),
+                "route_tables": getattr(dep_analysis, 'route_tables', []),
+                "security_groups": getattr(dep_analysis, 'security_groups', []),
+                "internet_gateways": getattr(dep_analysis, 'internet_gateways', []),
+                "nat_gateways": getattr(dep_analysis, 'nat_gateways', []),
+                "vpc_endpoints": getattr(dep_analysis, 'vpc_endpoints', []),
+                "peering_connections": getattr(dep_analysis, 'peering_connections', []),
+                "dependency_risk_level": getattr(dep_analysis, 'dependency_risk_level', 'unknown')
+            }
+        
+        candidates_data.append(candidate_dict)
+    
+    # Create export metadata
+    export_data = {
+        "metadata": {
+            "export_timestamp": datetime.now().isoformat(),
+            "total_candidates": len(candidates_data),
+            "generator": "CloudOps Runbooks VPC Module v0.9.9"
+        },
+        "vpc_candidates": candidates_data
+    }
+    
+    with open(filename, 'w', encoding='utf-8') as jsonfile:
+        json.dump(export_data, jsonfile, indent=2, ensure_ascii=False)
+    
+    return filename
+
+
+def _export_vpc_candidates_pdf(vpc_candidates: List[Any], output_dir: str) -> str:
+    """Export VPC candidates to PDF format for executive presentation."""
+    filename = os.path.join(output_dir, "vpc-cleanup-candidates.pdf")
+    
+    try:
+        # Try to use reportlab for PDF generation
+        from reportlab.lib import colors
+        from reportlab.lib.pagesizes import letter, A4
+        from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+        from reportlab.lib.styles import getSampleStyleSheet
+        
+        doc = SimpleDocTemplate(filename, pagesize=A4)
+        styles = getSampleStyleSheet()
+        story = []
+        
+        # Title
+        title = Paragraph("VPC Cleanup Analysis Report", styles['Title'])
+        story.append(title)
+        story.append(Spacer(1, 20))
+        
+        # Summary
+        summary_text = f"""
+        <b>Generated:</b> {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}<br/>
+        <b>Total VPC Candidates:</b> {len(vpc_candidates)}<br/>
+        <b>Analysis Source:</b> CloudOps Runbooks VPC Module v0.9.9
+        """
+        summary = Paragraph(summary_text, styles['Normal'])
+        story.append(summary)
+        story.append(Spacer(1, 20))
+        
+        # Create table data
+        table_data = [
+            ["Account ID", "VPC ID", "VPC Name", "CIDR", "Default", "ENI Count", "Decision"]
+        ]
+        
+        for candidate in vpc_candidates:
+            row = [
+                str(getattr(candidate, 'account_id', 'Unknown'))[:15],  # Truncate for PDF width
+                str(getattr(candidate, 'vpc_id', ''))[:20],
+                str(getattr(candidate, 'vpc_name', 'Unnamed'))[:15],
+                str(getattr(candidate, 'cidr_block', ''))[:15],
+                "Yes" if getattr(candidate, 'is_default', False) else "No",
+                str(getattr(candidate, 'dependency_analysis', {}).eni_count if hasattr(candidate, 'dependency_analysis') else 0),
+                str(getattr(candidate, 'cleanup_recommendation', 'unknown'))[:10]
+            ]
+            table_data.append(row)
+        
+        # Create table
+        table = Table(table_data)
+        table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('FONTSIZE', (0, 1), (-1, -1), 8),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black)
+        ]))
+        
+        story.append(table)
+        doc.build(story)
+        
+    except ImportError:
+        # Fallback: create a simple text-based PDF placeholder
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write("VPC Cleanup Analysis Report (PDF)\n")
+            f.write("=" * 40 + "\n\n")
+            f.write(f"Generated: {datetime.now().isoformat()}\n")
+            f.write(f"Total VPC Candidates: {len(vpc_candidates)}\n\n")
+            
+            for i, candidate in enumerate(vpc_candidates, 1):
+                f.write(f"{i}. VPC {getattr(candidate, 'vpc_id', 'Unknown')}\n")
+                f.write(f"   Account: {getattr(candidate, 'account_id', 'Unknown')}\n")
+                f.write(f"   CIDR: {getattr(candidate, 'cidr_block', 'Unknown')}\n")
+                f.write(f"   ENI Count: {getattr(candidate, 'dependency_analysis', {}).eni_count if hasattr(candidate, 'dependency_analysis') else 0}\n")
+                f.write(f"   Decision: {getattr(candidate, 'cleanup_recommendation', 'unknown')}\n\n")
+    
+    return filename