aws-inventory-manager 0.17.12__py3-none-any.whl

src/snapshot/report_formatter.py

@@ -0,0 +1,250 @@
+"""
+Report output formatting using Rich for terminal UI.
+
+This module contains the ReportFormatter class responsible for rendering
+reports to the terminal with Rich tables, progress bars, and formatted output.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+
+from src.models.report import DetailedResource, ResourceSummary, SnapshotMetadata
+from src.utils.pagination import paginate_resources
+
+
+class ReportFormatter:
+    """
+    Formats and renders reports using Rich terminal UI.
+
+    Handles rendering of headers, summaries, tables, and progress bars
+    for snapshot resource reports.
+    """
+
+    def __init__(self, console: Optional[Console] = None) -> None:
+        """
+        Initialize formatter with Rich Console.
+
+        Args:
+            console: Rich Console instance (creates default if not provided)
+        """
+        self.console = console or Console()
+
+    def format_summary(
+        self,
+        metadata: SnapshotMetadata,
+        summary: ResourceSummary,
+        has_filters: bool = False,
+    ) -> None:
+        """
+        Format and display complete summary report.
+
+        Orchestrates all render methods to display header, service breakdown,
+        region breakdown, and type breakdown.
+
+        Args:
+            metadata: Snapshot metadata for header
+            summary: Resource summary with aggregated counts
+            has_filters: Whether filters were applied (shows "Filtered" indicator)
+        """
+        # Render header
+        self._render_header(metadata, has_filters)
+
+        # Add spacing
+        self.console.print()
+
+        # Render summary sections
+        self.console.print("📊 [bold]Resource Summary[/bold]\n")
+        self.console.print(f"Total Resources: [bold cyan]{summary.total_count:,}[/bold cyan]\n")
+
+        if summary.total_count > 0:
+            # Render service breakdown
+            self._render_service_breakdown(summary)
+
+            # Render region breakdown
+            self._render_region_breakdown(summary)
+
+            # Render type breakdown (top 10)
+            self._render_type_breakdown(summary)
+
+    def _render_header(self, metadata: SnapshotMetadata, has_filters: bool = False) -> None:
+        """
+        Render report header with snapshot metadata.
+
+        Args:
+            metadata: Snapshot metadata
+            has_filters: Whether to show "Filtered" indicator
+        """
+        title = f"Snapshot Report: {metadata.name}"
+        if has_filters:
+            title += " (Filtered)"
+
+        # Create header panel
+        header_content = f"""[bold]Inventory:[/bold]     {metadata.inventory_name}
+[bold]Account ID:[/bold]    {metadata.account_id}
+[bold]Created:[/bold]       {metadata.created_at.strftime('%Y-%m-%d %H:%M:%S UTC')}
+[bold]Regions:[/bold]       {metadata.region_summary}"""
+
+        panel = Panel(
+            header_content,
+            title=title,
+            border_style="blue",
+            expand=False,
+        )
+
+        self.console.print(panel)
+
+    def _render_service_breakdown(self, summary: ResourceSummary) -> None:
+        """
+        Render service breakdown with progress bars.
+
+        Args:
+            summary: Resource summary with service counts
+        """
+        if not summary.by_service:
+            return
+
+        self.console.print("[bold]By Service:[/bold]")
+
+        # Get top services (sorted by count)
+        top_services = summary.top_services(limit=10)
+
+        for service, count in top_services:
+            percentage = (count / summary.total_count) * 100
+            bar_length = int((count / summary.total_count) * 30)
+            bar = "█" * bar_length + "░" * (30 - bar_length)
+
+            self.console.print(f"  {service:15} {count:5}  {bar}  ({percentage:.1f}%)")
+
+        self.console.print()
+
+    def _render_region_breakdown(self, summary: ResourceSummary) -> None:
+        """
+        Render region breakdown with progress bars.
+
+        Args:
+            summary: Resource summary with region counts
+        """
+        if not summary.by_region:
+            return
+
+        self.console.print("[bold]By Region:[/bold]")
+
+        # Get top regions (sorted by count)
+        top_regions = summary.top_regions(limit=10)
+
+        for region, count in top_regions:
+            percentage = (count / summary.total_count) * 100
+            bar_length = int((count / summary.total_count) * 30)
+            bar = "█" * bar_length + "░" * (30 - bar_length)
+
+            self.console.print(f"  {region:15} {count:5}  {bar}  ({percentage:.1f}%)")
+
+        self.console.print()
+
+    def _render_type_breakdown(self, summary: ResourceSummary) -> None:
+        """
+        Render resource type breakdown showing top 10 types.
+
+        Args:
+            summary: Resource summary with type counts
+        """
+        if not summary.by_type:
+            return
+
+        self.console.print("[bold]Top 10 Resource Types:[/bold]")
+
+        # Get top 10 resource types
+        sorted_types = sorted(
+            summary.by_type.items(),
+            key=lambda x: x[1],
+            reverse=True,
+        )[:10]
+
+        for resource_type, count in sorted_types:
+            percentage = (count / summary.total_count) * 100
+            self.console.print(f"  {resource_type:45} {count:5}  ({percentage:.1f}%)")
+
+        self.console.print()
+
+    def format_detailed(
+        self,
+        metadata: SnapshotMetadata,
+        resources: List[DetailedResource],
+        page_size: int = 100,
+    ) -> None:
+        """
+        Format and display detailed resource view with pagination.
+
+        Args:
+            metadata: Snapshot metadata for header
+            resources: List of detailed resources to display
+            page_size: Number of resources per page (default: 100)
+        """
+        # Render header
+        self._render_header(metadata, has_filters=False)
+        self.console.print()
+
+        total_resources = len(resources)
+        self.console.print(f"Total Resources: [bold cyan]{total_resources:,}[/bold cyan]\n")
+
+        if total_resources == 0:
+            return
+
+        # Paginate resources
+        pages = list(paginate_resources(resources, page_size=page_size))
+        total_pages = len(pages)
+
+        # Display pages
+        for page_num, page in enumerate(pages, start=1):
+            for idx, resource in enumerate(page, start=1):
+                global_idx = (page_num - 1) * page_size + idx
+                self._render_detailed_resource(resource, global_idx, total_resources)
+
+            # Show pagination info (but no prompts - non-interactive for now)
+            if page_num < total_pages:
+                self.console.print(f"\n[dim]─── Page {page_num} of {total_pages} ───[/dim]\n")
+
+    def _render_detailed_resource(
+        self,
+        resource: DetailedResource,
+        index: int,
+        total: int,
+    ) -> None:
+        """
+        Render a single detailed resource.
+
+        Args:
+            resource: DetailedResource to display
+            index: Resource index (1-based)
+            total: Total number of resources
+        """
+        self.console.print("─" * 65)
+        self.console.print(f"[bold]Resource {index}/{total}[/bold]\n")
+
+        self.console.print(f"[bold]ARN:[/bold]          {resource.arn}")
+        self.console.print(f"[bold]Type:[/bold]         {resource.resource_type}")
+        self.console.print(f"[bold]Name:[/bold]         {resource.name}")
+        self.console.print(f"[bold]Region:[/bold]       {resource.region}")
+
+        # Show creation date if available
+        if resource.created_at:
+            age_str = ""
+            if resource.age_days is not None:
+                age_str = f" ({resource.age_days} days ago)"
+            created_str = resource.created_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+            self.console.print(f"[bold]Created:[/bold]      {created_str}{age_str}")
+
+        # Show tags
+        self.console.print()
+        if resource.tags:
+            self.console.print("[bold]Tags:[/bold]")
+            for key, value in resource.tags.items():
+                self.console.print(f"  {key:20} {value}")
+        else:
+            self.console.print("[dim]No tags[/dim]")
+
+        self.console.print()

src/snapshot/reporter.py

@@ -0,0 +1,189 @@
+"""
+Snapshot report generation logic.
+
+This module contains the SnapshotReporter class responsible for generating
+reports from snapshot data, including summary generation, filtering, and
+detailed resource views.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generator, Optional
+
+from src.models.report import DetailedResource, FilterCriteria, FilteredResource, ResourceSummary, SnapshotMetadata
+
+if TYPE_CHECKING:
+    from src.models.snapshot import Snapshot
+
+
+class SnapshotReporter:
+    """
+    Generates reports from snapshot data.
+
+    This class handles extracting metadata, generating summaries, and
+    preparing data for formatting and display.
+    """
+
+    def __init__(self, snapshot: Snapshot) -> None:
+        """
+        Initialize reporter with a snapshot.
+
+        Args:
+            snapshot: The snapshot to generate reports from
+        """
+        self.snapshot = snapshot
+
+    def _extract_metadata(self) -> SnapshotMetadata:
+        """
+        Extract metadata from snapshot for report header.
+
+        Returns:
+            SnapshotMetadata with snapshot information
+        """
+        return SnapshotMetadata(
+            name=self.snapshot.name,
+            created_at=self.snapshot.created_at,
+            account_id=self.snapshot.account_id,
+            regions=self.snapshot.regions,
+            inventory_name=self.snapshot.inventory_name,
+            total_resource_count=len(self.snapshot.resources),
+        )
+
+    def generate_summary(self) -> ResourceSummary:
+        """
+        Generate aggregated resource summary from snapshot.
+
+        Uses streaming single-pass aggregation for memory efficiency.
+        Does not load entire dataset into memory.
+
+        Returns:
+            ResourceSummary with aggregated counts
+        """
+        summary = ResourceSummary()
+
+        # Single-pass streaming aggregation
+        for resource in self.snapshot.resources:
+            summary.total_count += 1
+
+            # Extract service from resource type
+            # Handle both formats: "AWS::EC2::Instance" and "ec2:instance"
+            if "::" in resource.resource_type:
+                # CloudFormation format: AWS::EC2::Instance
+                parts = resource.resource_type.split("::")
+                service = parts[1] if len(parts) >= 2 else "Unknown"
+            else:
+                # Simplified format: ec2:instance
+                service = (
+                    resource.resource_type.split(":")[0] if ":" in resource.resource_type else resource.resource_type
+                )
+
+            # Aggregate by service
+            summary.by_service[service] = summary.by_service.get(service, 0) + 1
+
+            # Aggregate by region
+            summary.by_region[resource.region] = summary.by_region.get(resource.region, 0) + 1
+
+            # Aggregate by type
+            summary.by_type[resource.resource_type] = summary.by_type.get(resource.resource_type, 0) + 1
+
+        return summary
+
+    def get_filtered_resources(self, criteria: FilterCriteria) -> Generator[FilteredResource, None, None]:
+        """
+        Get filtered resources as generator (memory-efficient streaming).
+
+        Args:
+            criteria: Filter criteria with resource types and/or regions
+
+        Yields:
+            FilteredResource objects matching the criteria
+        """
+        for resource in self.snapshot.resources:
+            # Convert Resource to FilteredResource for matching
+            filtered_resource = FilteredResource(
+                arn=resource.arn,
+                resource_type=resource.resource_type,
+                name=resource.name,
+                region=resource.region,
+            )
+
+            # Apply filter criteria
+            if criteria.matches_resource(filtered_resource):
+                yield filtered_resource
+
+    def generate_filtered_summary(self, criteria: FilterCriteria) -> ResourceSummary:
+        """
+        Generate summary for filtered resources only.
+
+        Args:
+            criteria: Filter criteria
+
+        Returns:
+            ResourceSummary with counts for filtered resources only
+        """
+        summary = ResourceSummary()
+
+        # Single-pass streaming aggregation of filtered resources
+        for filtered_resource in self.get_filtered_resources(criteria):
+            summary.total_count += 1
+
+            # Extract service from resource type
+            if "::" in filtered_resource.resource_type:
+                parts = filtered_resource.resource_type.split("::")
+                service = parts[1] if len(parts) >= 2 else "Unknown"
+            else:
+                service = (
+                    filtered_resource.resource_type.split(":")[0]
+                    if ":" in filtered_resource.resource_type
+                    else filtered_resource.resource_type
+                )
+
+            # Aggregate by service
+            summary.by_service[service] = summary.by_service.get(service, 0) + 1
+
+            # Aggregate by region
+            summary.by_region[filtered_resource.region] = summary.by_region.get(filtered_resource.region, 0) + 1
+
+            # Aggregate by type
+            summary.by_type[filtered_resource.resource_type] = (
+                summary.by_type.get(filtered_resource.resource_type, 0) + 1
+            )
+
+        return summary
+
+    def get_detailed_resources(
+        self, criteria: Optional[FilterCriteria] = None
+    ) -> Generator[DetailedResource, None, None]:
+        """
+        Get detailed resource information as generator.
+
+        Args:
+            criteria: Optional filter criteria to limit resources
+
+        Yields:
+            DetailedResource objects with full information (tags, creation date, etc.)
+        """
+        for resource in self.snapshot.resources:
+            # Apply filtering if criteria provided
+            if criteria:
+                filtered_resource = FilteredResource(
+                    arn=resource.arn,
+                    resource_type=resource.resource_type,
+                    name=resource.name,
+                    region=resource.region,
+                )
+                if not criteria.matches_resource(filtered_resource):
+                    continue
+
+            # Convert Resource to DetailedResource
+            detailed_resource = DetailedResource(
+                arn=resource.arn,
+                resource_type=resource.resource_type,
+                name=resource.name,
+                region=resource.region,
+                tags=resource.tags,
+                created_at=resource.created_at,
+                config_hash=resource.config_hash,
+            )
+
+            yield detailed_resource

src/snapshot/resource_collectors/__init__.py

@@ -0,0 +1,5 @@
+"""Resource collectors for AWS services."""
+
+from typing import List
+
+__all__: List[str] = []

src/snapshot/resource_collectors/apigateway.py

@@ -0,0 +1,140 @@
+"""API Gateway resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class APIGatewayCollector(BaseResourceCollector):
+    """Collector for AWS API Gateway resources (REST, HTTP, WebSocket APIs)."""
+
+    @property
+    def service_name(self) -> str:
+        return "apigateway"
+
+    def collect(self) -> List[Resource]:
+        """Collect API Gateway resources.
+
+        Collects:
+        - REST APIs (v1)
+        - HTTP APIs (v2)
+        - WebSocket APIs (v2)
+
+        Returns:
+            List of API Gateway APIs
+        """
+        resources = []
+
+        # Collect REST APIs (v1)
+        resources.extend(self._collect_rest_apis())
+
+        # Collect HTTP and WebSocket APIs (v2)
+        resources.extend(self._collect_v2_apis())
+
+        self.logger.debug(f"Collected {len(resources)} API Gateway APIs in {self.region}")
+        return resources
+
+    def _collect_rest_apis(self) -> List[Resource]:
+        """Collect REST APIs (API Gateway v1).
+
+        Returns:
+            List of REST API resources
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("get_rest_apis")
+            for page in paginator.paginate():
+                for api in page.get("items", []):
+                    api_id = api["id"]
+                    api_name = api["name"]
+
+                    # Get tags
+                    tags = {}
+                    try:
+                        tag_response = client.get_tags(
+                            resourceArn=f"arn:aws:apigateway:{self.region}::/restapis/{api_id}"
+                        )
+                        tags = tag_response.get("tags", {})
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for REST API {api_id}: {e}")
+
+                    # Build ARN
+                    arn = f"arn:aws:apigateway:{self.region}::/restapis/{api_id}"
+
+                    # Extract creation date
+                    created_at = api.get("createdDate")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::ApiGateway::RestApi",
+                        name=api_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(api),
+                        created_at=created_at,
+                        raw_config=api,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting REST APIs in {self.region}: {e}")
+
+        return resources
+
+    def _collect_v2_apis(self) -> List[Resource]:
+        """Collect HTTP and WebSocket APIs (API Gateway v2).
+
+        Returns:
+            List of v2 API resources
+        """
+        resources = []
+
+        try:
+            client = self._create_client("apigatewayv2")
+
+            paginator = client.get_paginator("get_apis")
+            for page in paginator.paginate():
+                for api in page.get("Items", []):
+                    api_id = api["ApiId"]
+                    api_name = api["Name"]
+                    protocol_type = api["ProtocolType"]  # HTTP or WEBSOCKET
+
+                    # Get tags
+                    tags = api.get("Tags", {})
+
+                    # Build ARN
+                    arn = f"arn:aws:apigateway:{self.region}::/apis/{api_id}"
+
+                    # Extract creation date
+                    created_at = api.get("CreatedDate")
+
+                    # Determine resource type based on protocol
+                    if protocol_type == "HTTP":
+                        resource_type = "AWS::ApiGatewayV2::Api::HTTP"
+                    elif protocol_type == "WEBSOCKET":
+                        resource_type = "AWS::ApiGatewayV2::Api::WebSocket"
+                    else:
+                        resource_type = f"AWS::ApiGatewayV2::Api::{protocol_type}"
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type=resource_type,
+                        name=api_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(api),
+                        created_at=created_at,
+                        raw_config=api,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting API Gateway v2 APIs in {self.region}: {e}")
+
+        return resources