aws-inventory-manager 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/utils/export.py

@@ -4,7 +4,10 @@ import csv
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List
+
+if TYPE_CHECKING:
+    from src.models.report import DetailedResource, ResourceSummary, SnapshotMetadata
 
 logger = logging.getLogger(__name__)
 
@@ -85,3 +88,218 @@ def flatten_dict(d: Dict[str, Any], parent_key: str = "", sep: str = "_") -> Dic
         else:
             items.append((new_key, v))
     return dict(items)
+
+
+def detect_format(filepath: str) -> str:
+    """
+    Detect export format from file extension.
+
+    Args:
+        filepath: Path to file
+
+    Returns:
+        Format string: 'json', 'csv', or 'txt'
+
+    Raises:
+        ValueError: If format is not supported
+    """
+    path = Path(filepath)
+    extension = path.suffix.lower()
+
+    if extension == ".json":
+        return "json"
+    elif extension == ".csv":
+        return "csv"
+    elif extension == ".txt":
+        return "txt"
+    else:
+        raise ValueError(f"Unsupported export format '{extension}'. " f"Supported formats: .json, .csv, .txt")
+
+
+def export_report_json(
+    filepath: str,
+    metadata: "SnapshotMetadata",
+    summary: "ResourceSummary",
+    resources: List["DetailedResource"],
+) -> Path:
+    """
+    Export snapshot report to JSON format.
+
+    Args:
+        filepath: Destination file path
+        metadata: Snapshot metadata
+        summary: Resource summary
+        resources: List of detailed resources
+
+    Returns:
+        Path to exported file
+
+    Raises:
+        FileExistsError: If file already exists
+        FileNotFoundError: If parent directory doesn't exist
+    """
+    path = Path(filepath)
+
+    # Check if file already exists
+    if path.exists():
+        raise FileExistsError(f"Export file '{filepath}' already exists")
+
+    # Check if parent directory exists
+    if not path.parent.exists():
+        raise FileNotFoundError(f"Parent directory '{path.parent}' does not exist")
+
+    # Build report data structure
+    report_data = {
+        "snapshot_metadata": {
+            "name": metadata.name,
+            "created_at": metadata.created_at.isoformat(),
+            "account_id": metadata.account_id,
+            "regions": metadata.regions,
+            "inventory_name": metadata.inventory_name,
+            "total_resource_count": metadata.total_resource_count,
+        },
+        "summary": {
+            "total_count": summary.total_count,
+            "by_service": dict(summary.by_service),
+            "by_region": dict(summary.by_region),
+            "by_type": dict(summary.by_type),
+        },
+        "resources": [
+            {
+                "arn": r.arn,
+                "resource_type": r.resource_type,
+                "name": r.name,
+                "region": r.region,
+                "tags": r.tags,
+                "created_at": r.created_at.isoformat() if r.created_at else None,
+                "config_hash": r.config_hash,
+            }
+            for r in resources
+        ],
+    }
+
+    # Write to file
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(report_data, f, indent=2)
+
+    logger.info(f"Exported report to JSON: {path}")
+    return path
+
+
+def export_report_csv(filepath: str, resources: List["DetailedResource"]) -> Path:
+    """
+    Export resources to CSV format.
+
+    Args:
+        filepath: Destination file path
+        resources: List of detailed resources
+
+    Returns:
+        Path to exported file
+
+    Raises:
+        FileExistsError: If file already exists
+        FileNotFoundError: If parent directory doesn't exist
+    """
+    path = Path(filepath)
+
+    # Check if file already exists
+    if path.exists():
+        raise FileExistsError(f"Export file '{filepath}' already exists")
+
+    # Check if parent directory exists
+    if not path.parent.exists():
+        raise FileNotFoundError(f"Parent directory '{path.parent}' does not exist")
+
+    # Write CSV
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+
+        # Write header
+        writer.writerow(["ARN", "ResourceType", "Name", "Region", "CreatedAt", "Tags"])
+
+        # Write resources
+        for resource in resources:
+            writer.writerow(
+                [
+                    resource.arn,
+                    resource.resource_type,
+                    resource.name,
+                    resource.region,
+                    resource.created_at.isoformat() if resource.created_at else "",
+                    json.dumps(resource.tags) if resource.tags else "{}",
+                ]
+            )
+
+    logger.info(f"Exported {len(resources)} resources to CSV: {path}")
+    return path
+
+
+def export_report_txt(
+    filepath: str,
+    metadata: "SnapshotMetadata",
+    summary: "ResourceSummary",
+) -> Path:
+    """
+    Export report summary to plain text format.
+
+    Args:
+        filepath: Destination file path
+        metadata: Snapshot metadata
+        summary: Resource summary
+
+    Returns:
+        Path to exported file
+
+    Raises:
+        FileExistsError: If file already exists
+        FileNotFoundError: If parent directory doesn't exist
+    """
+    path = Path(filepath)
+
+    # Check if file already exists
+    if path.exists():
+        raise FileExistsError(f"Export file '{filepath}' already exists")
+
+    # Check if parent directory exists
+    if not path.parent.exists():
+        raise FileNotFoundError(f"Parent directory '{path.parent}' does not exist")
+
+    # Build text content
+    lines = []
+    lines.append("=" * 65)
+    lines.append(f"Snapshot Report: {metadata.name}")
+    lines.append("=" * 65)
+    lines.append("")
+    lines.append(f"Inventory:     {metadata.inventory_name}")
+    lines.append(f"Account ID:    {metadata.account_id}")
+    lines.append(f"Created:       {metadata.created_at.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+    lines.append(f"Regions:       {metadata.region_summary}")
+    lines.append("")
+    lines.append("─" * 65)
+    lines.append("")
+    lines.append("Resource Summary")
+    lines.append("")
+    lines.append(f"Total Resources: {summary.total_count:,}")
+    lines.append("")
+
+    if summary.by_service:
+        lines.append("By Service:")
+        for service, count in summary.top_services(limit=10):
+            percentage = (count / summary.total_count) * 100 if summary.total_count > 0 else 0
+            lines.append(f"  {service:20} {count:5}  ({percentage:.1f}%)")
+        lines.append("")
+
+    if summary.by_region:
+        lines.append("By Region:")
+        for region, count in summary.top_regions(limit=10):
+            percentage = (count / summary.total_count) * 100 if summary.total_count > 0 else 0
+            lines.append(f"  {region:20} {count:5}  ({percentage:.1f}%)")
+        lines.append("")
+
+    # Write to file
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+    logger.info(f"Exported report to TXT: {path}")
+    return path

src/utils/pagination.py

@@ -0,0 +1,41 @@
+"""
+Terminal pagination utilities for large resource lists.
+
+This module provides pagination functionality for displaying large datasets
+in the terminal with user-friendly navigation controls.
+"""
+
+from __future__ import annotations
+
+from typing import Generator, List, TypeVar
+
+T = TypeVar("T")
+
+
+def paginate_resources(items: List[T], page_size: int = 100) -> Generator[List[T], None, None]:
+    """
+    Paginate a list of items into pages of specified size.
+
+    This is a memory-efficient generator that yields pages of items
+    without loading everything into memory at once.
+
+    Args:
+        items: List of items to paginate
+        page_size: Number of items per page (default: 100)
+
+    Yields:
+        Lists of items, each containing up to page_size items
+
+    Example:
+        >>> resources = list(range(250))
+        >>> for page in paginate_resources(resources, page_size=100):
+        ...     print(f"Page has {len(page)} items")
+        Page has 100 items
+        Page has 100 items
+        Page has 50 items
+    """
+    if not items:
+        return
+
+    for i in range(0, len(items), page_size):
+        yield items[i : i + page_size]