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

src/delta/calculator.py

@@ -0,0 +1,180 @@
+"""Delta calculator for comparing snapshots."""
+
+import logging
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from ..models.delta_report import DeltaReport, ResourceChange
+from ..models.resource import Resource
+from ..models.snapshot import Snapshot
+
+logger = logging.getLogger(__name__)
+
+
+class DeltaCalculator:
+    """Calculate differences between two snapshots."""
+
+    def __init__(self, reference_snapshot: Snapshot, current_snapshot: Snapshot):
+        """Initialize delta calculator.
+
+        Args:
+            reference_snapshot: The reference snapshot to compare against
+            current_snapshot: The current snapshot
+        """
+        self.reference = reference_snapshot
+        self.current = current_snapshot
+
+        # Index resources by ARN for fast lookup
+        self.reference_index = {r.arn: r for r in reference_snapshot.resources}
+        self.current_index = {r.arn: r for r in current_snapshot.resources}
+
+    def calculate(
+        self,
+        resource_type_filter: Optional[List[str]] = None,
+        region_filter: Optional[List[str]] = None,
+    ) -> DeltaReport:
+        """Calculate delta between reference and current snapshots.
+
+        Args:
+            resource_type_filter: Optional list of resource types to include
+            region_filter: Optional list of regions to include
+
+        Returns:
+            DeltaReport with added, deleted, and modified resources
+        """
+        logger.info("Calculating delta between reference and current snapshots")
+
+        added_resources = []
+        deleted_resources = []
+        modified_resources = []
+
+        reference_arns = set(self.reference_index.keys())
+        current_arns = set(self.current_index.keys())
+
+        # Find added resources (in current but not in reference)
+        added_arns = current_arns - reference_arns
+        for arn in added_arns:
+            resource = self.current_index[arn]
+            if self._matches_filters(resource, resource_type_filter, region_filter):
+                added_resources.append(resource)
+
+        # Find deleted resources (in reference but not in current)
+        deleted_arns = reference_arns - current_arns
+        for arn in deleted_arns:
+            resource = self.reference_index[arn]
+            if self._matches_filters(resource, resource_type_filter, region_filter):
+                deleted_resources.append(resource)
+
+        # Find modified resources (in both but with different config)
+        common_arns = reference_arns & current_arns
+        for arn in common_arns:
+            reference_resource = self.reference_index[arn]
+            current_resource = self.current_index[arn]
+
+            if self._matches_filters(current_resource, resource_type_filter, region_filter):
+                # Compare config hashes to detect modifications
+                if reference_resource.config_hash != current_resource.config_hash:
+                    change = ResourceChange(
+                        resource=current_resource,
+                        baseline_resource=reference_resource,
+                        change_type="modified",
+                        old_config_hash=reference_resource.config_hash,
+                        new_config_hash=current_resource.config_hash,
+                    )
+                    modified_resources.append(change)
+
+        # Create delta report
+        report = DeltaReport(
+            generated_at=datetime.now(timezone.utc),
+            baseline_snapshot_name=self.reference.name,
+            current_snapshot_name=self.current.name,
+            added_resources=added_resources,
+            deleted_resources=deleted_resources,
+            modified_resources=modified_resources,
+            baseline_resource_count=len(self.reference.resources),
+            current_resource_count=len(self.current.resources),
+        )
+
+        logger.info(
+            f"Delta calculated: {len(added_resources)} added, "
+            f"{len(deleted_resources)} deleted, {len(modified_resources)} modified"
+        )
+
+        return report
+
+    def _matches_filters(
+        self,
+        resource: Resource,
+        resource_type_filter: Optional[List[str]],
+        region_filter: Optional[List[str]],
+    ) -> bool:
+        """Check if resource matches the specified filters.
+
+        Args:
+            resource: Resource to check
+            resource_type_filter: Optional list of resource types to include
+            region_filter: Optional list of regions to include
+
+        Returns:
+            True if resource matches all filters
+        """
+        # Check resource type filter
+        if resource_type_filter:
+            if resource.resource_type not in resource_type_filter:
+                return False
+
+        # Check region filter
+        if region_filter:
+            if resource.region not in region_filter:
+                return False
+
+        return True
+
+
+def compare_to_current_state(
+    reference_snapshot: Snapshot,
+    profile_name: Optional[str] = None,
+    regions: Optional[List[str]] = None,
+    resource_type_filter: Optional[List[str]] = None,
+    region_filter: Optional[List[str]] = None,
+) -> DeltaReport:
+    """Compare reference snapshot to current AWS state.
+
+    This is a convenience function that captures current state and calculates delta.
+
+    Args:
+        reference_snapshot: The reference snapshot to compare against
+        profile_name: AWS profile name (optional)
+        regions: Regions to scan (defaults to reference snapshot regions)
+        resource_type_filter: Optional list of resource types to include in delta
+        region_filter: Optional list of regions to include in delta
+
+    Returns:
+        DeltaReport with changes
+    """
+    from ..aws.credentials import get_account_id
+    from ..snapshot.capturer import create_snapshot
+
+    # Use reference snapshot regions if not specified
+    if not regions:
+        regions = reference_snapshot.regions
+
+    # Get account ID
+    account_id = get_account_id(profile_name)
+
+    # Capture current state (don't save it, just use for comparison)
+    logger.info("Capturing current AWS state for comparison...")
+    current_snapshot = create_snapshot(
+        name=f"temp-current-{datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}",
+        regions=regions,
+        account_id=account_id,
+        profile_name=profile_name,
+        set_active=False,
+    )
+
+    # Calculate delta
+    calculator = DeltaCalculator(reference_snapshot, current_snapshot)
+    return calculator.calculate(
+        resource_type_filter=resource_type_filter,
+        region_filter=region_filter,
+    )

src/delta/reporter.py

@@ -0,0 +1,225 @@
+"""Delta report formatting and display."""
+
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..models.delta_report import DeltaReport
+
+
+class DeltaReporter:
+    """Format and display delta reports."""
+
+    def __init__(self, console: Optional[Console] = None):
+        """Initialize delta reporter.
+
+        Args:
+            console: Rich console instance (creates new one if not provided)
+        """
+        self.console = console or Console()
+
+    def display(self, report: DeltaReport, show_details: bool = False) -> None:
+        """Display delta report to console.
+
+        Args:
+            report: DeltaReport to display
+            show_details: Whether to show detailed resource information
+        """
+        # Header
+        self.console.print()
+        self.console.print(
+            Panel(
+                f"[bold]Resource Delta Report[/bold]\n"
+                f"Reference Snapshot: {report.baseline_snapshot_name}\n"
+                f"Generated: {report.generated_at.strftime('%Y-%m-%d %H:%M:%S UTC')}",
+                style="cyan",
+            )
+        )
+        self.console.print()
+
+        # Check if there are any changes
+        if not report.has_changes:
+            self.console.print(
+                "[green]✓ No changes detected - environment matches reference snapshot[/green]", style="bold"
+            )
+            self.console.print()
+            self.console.print(f"Total resources: {report.baseline_resource_count}")
+            return
+
+        # Summary statistics
+        self._display_summary(report)
+
+        # Group changes by service
+        grouped = report.group_by_service()
+
+        # Display changes by service
+        for service_type in sorted(grouped.keys()):
+            changes = grouped[service_type]
+            if any(changes.values()):
+                self._display_service_changes(service_type, changes, show_details)
+
+    def _display_summary(self, report: DeltaReport) -> None:
+        """Display summary statistics."""
+        table = Table(title="Summary", show_header=True, header_style="bold magenta")
+        table.add_column("Change Type", style="cyan", width=15)
+        table.add_column("Count", justify="right", style="yellow", width=10)
+
+        added_count = len(report.added_resources)
+        deleted_count = len(report.deleted_resources)
+        modified_count = len(report.modified_resources)
+        unchanged_count = report.unchanged_count
+
+        if added_count > 0:
+            table.add_row("➕ Added", f"[green]{added_count}[/green]")
+        if deleted_count > 0:
+            table.add_row("➖ Deleted", f"[red]{deleted_count}[/red]")
+        if modified_count > 0:
+            table.add_row("🔄 Modified", f"[yellow]{modified_count}[/yellow]")
+        if unchanged_count > 0:
+            table.add_row("✓ Unchanged", str(unchanged_count))
+
+        table.add_row("━" * 15, "━" * 10, style="dim")
+        table.add_row("[bold]Total Changes", f"[bold]{report.total_changes}")
+
+        self.console.print(table)
+        self.console.print()
+
+    def _display_service_changes(self, service_type: str, changes: dict, show_details: bool) -> None:
+        """Display changes for a specific service type.
+
+        Args:
+            service_type: AWS resource type (e.g., 'AWS::EC2::Instance')
+            changes: Dictionary with 'added', 'deleted', 'modified' lists
+            show_details: Whether to show detailed information
+        """
+        # Count total changes for this service
+        total = len(changes["added"]) + len(changes["deleted"]) + len(changes["modified"])
+        if total == 0:
+            return
+
+        self.console.print(f"[bold cyan]{service_type}[/bold cyan] ({total} changes)")
+
+        # Create table for this service
+        table = Table(show_header=True, box=None, padding=(0, 2))
+        table.add_column("Change", width=8)
+        table.add_column("Name", style="white")
+        table.add_column("Region", width=15)
+        table.add_column("ARN" if show_details else "Tags", style="dim")
+
+        # Added resources
+        for resource in changes["added"]:
+            tags_str = self._format_tags(resource.tags)
+            arn_or_tags = resource.arn if show_details else tags_str
+            table.add_row("[green]➕ Add[/green]", resource.name, resource.region, arn_or_tags)
+
+        # Deleted resources
+        for resource in changes["deleted"]:
+            tags_str = self._format_tags(resource.tags)
+            arn_or_tags = resource.arn if show_details else tags_str
+            table.add_row("[red]➖ Del[/red]", resource.name, resource.region, arn_or_tags)
+
+        # Modified resources
+        for change in changes["modified"]:
+            tags_str = self._format_tags(change.resource.tags)
+            arn_or_tags = change.resource.arn if show_details else tags_str
+            table.add_row("[yellow]🔄 Mod[/yellow]", change.resource.name, change.resource.region, arn_or_tags)
+
+        self.console.print(table)
+        self.console.print()
+
+    def _format_tags(self, tags: dict) -> str:
+        """Format tags dictionary as a string.
+
+        Args:
+            tags: Dictionary of tag key-value pairs
+
+        Returns:
+            Formatted string like "Env=prod, App=web"
+        """
+        if not tags:
+            return "-"
+
+        # Show up to 3 most important tags
+        important_keys = ["Name", "Environment", "Project", "Team", "Application"]
+        selected_tags = []
+
+        # First add important tags if present
+        for key in important_keys:
+            if key in tags:
+                selected_tags.append(f"{key}={tags[key]}")
+
+        # Add other tags up to limit
+        for key, value in tags.items():
+            if key not in important_keys and len(selected_tags) < 3:
+                selected_tags.append(f"{key}={value}")
+
+        return ", ".join(selected_tags[:3])
+
+    def export_json(self, report: DeltaReport, filepath: str) -> None:
+        """Export delta report to JSON file.
+
+        Args:
+            report: DeltaReport to export
+            filepath: Destination file path
+        """
+        from ..utils.export import export_to_json
+
+        export_to_json(report.to_dict(), filepath)
+        self.console.print(f"[green]✓ Delta report exported to {filepath}[/green]")
+
+    def export_csv(self, report: DeltaReport, filepath: str) -> None:
+        """Export delta report to CSV file.
+
+        Args:
+            report: DeltaReport to export
+            filepath: Destination file path
+        """
+        from ..utils.export import export_to_csv
+
+        # Flatten the report into rows
+        rows = []
+
+        for resource in report.added_resources:
+            rows.append(
+                {
+                    "change_type": "added",
+                    "resource_type": resource.resource_type,
+                    "name": resource.name,
+                    "arn": resource.arn,
+                    "region": resource.region,
+                    "tags": str(resource.tags),
+                    "created_at": resource.created_at.isoformat() if resource.created_at else None,
+                }
+            )
+
+        for resource in report.deleted_resources:
+            rows.append(
+                {
+                    "change_type": "deleted",
+                    "resource_type": resource.resource_type,
+                    "name": resource.name,
+                    "arn": resource.arn,
+                    "region": resource.region,
+                    "tags": str(resource.tags),
+                    "created_at": resource.created_at.isoformat() if resource.created_at else None,
+                }
+            )
+
+        for change in report.modified_resources:
+            rows.append(
+                {
+                    "change_type": "modified",
+                    "resource_type": change.resource.resource_type,
+                    "name": change.resource.name,
+                    "arn": change.resource.arn,
+                    "region": change.resource.region,
+                    "tags": str(change.resource.tags),
+                    "old_hash": change.old_config_hash,
+                    "new_hash": change.new_config_hash,
+                }
+            )
+
+        export_to_csv(rows, filepath)
+        self.console.print(f"[green]✓ Delta report exported to {filepath}[/green]")

src/models/__init__.py

@@ -0,0 +1,17 @@
+"""Data models for AWS Baseline Snapshot tool."""
+
+from .cost_report import CostBreakdown, CostReport
+from .delta_report import DeltaReport, ResourceChange
+from .inventory import Inventory
+from .resource import Resource
+from .snapshot import Snapshot
+
+__all__ = [
+    "Snapshot",
+    "Resource",
+    "DeltaReport",
+    "ResourceChange",
+    "CostReport",
+    "CostBreakdown",
+    "Inventory",
+]

src/models/cost_report.py

@@ -0,0 +1,87 @@
+"""Cost report models for cost analysis and tracking."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class CostBreakdown:
+    """Represents cost breakdown for baseline or non-baseline resources."""
+
+    total: float
+    by_service: Dict[str, float] = field(default_factory=dict)
+    percentage: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "total": self.total,
+            "by_service": self.by_service,
+            "percentage": self.percentage,
+        }
+
+
+@dataclass
+class CostReport:
+    """Represents cost analysis separating baseline vs non-baseline costs."""
+
+    generated_at: datetime
+    baseline_snapshot_name: str
+    period_start: datetime
+    period_end: datetime
+    baseline_costs: CostBreakdown
+    non_baseline_costs: CostBreakdown
+    total_cost: float
+    data_complete: bool = True
+    data_through: Optional[datetime] = None
+    lag_days: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "generated_at": self.generated_at.isoformat(),
+            "baseline_snapshot_name": self.baseline_snapshot_name,
+            "period_start": self.period_start.isoformat(),
+            "period_end": self.period_end.isoformat(),
+            "baseline_costs": self.baseline_costs.to_dict(),
+            "non_baseline_costs": self.non_baseline_costs.to_dict(),
+            "total_cost": self.total_cost,
+            "data_complete": self.data_complete,
+            "data_through": self.data_through.isoformat() if self.data_through else None,
+            "lag_days": self.lag_days,
+            "summary": {
+                "baseline_total": self.baseline_costs.total,
+                "baseline_percentage": self.baseline_costs.percentage,
+                "non_baseline_total": self.non_baseline_costs.total,
+                "non_baseline_percentage": self.non_baseline_costs.percentage,
+                "total": self.total_cost,
+            },
+        }
+
+    @property
+    def baseline_percentage(self) -> float:
+        """Get baseline cost percentage."""
+        return self.baseline_costs.percentage
+
+    @property
+    def non_baseline_percentage(self) -> float:
+        """Get non-baseline cost percentage."""
+        return self.non_baseline_costs.percentage
+
+    def get_top_services(self, limit: int = 5, baseline: bool = True) -> Dict[str, float]:
+        """Get top N services by cost.
+
+        Args:
+            limit: Number of top services to return
+            baseline: If True, return baseline services; if False, non-baseline
+
+        Returns:
+            Dictionary of service name to cost, sorted by cost descending
+        """
+        services = self.baseline_costs.by_service if baseline else self.non_baseline_costs.by_service
+
+        # Sort by cost descending
+        sorted_services = sorted(services.items(), key=lambda x: x[1], reverse=True)
+
+        return dict(sorted_services[:limit])

src/models/delta_report.py

@@ -0,0 +1,111 @@
+"""Delta report models for tracking resource changes."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ResourceChange:
+    """Represents a modified resource in a delta report."""
+
+    resource: Any  # Current Resource instance
+    baseline_resource: Any  # Reference Resource instance (keeping field name for compatibility)
+    change_type: str  # 'modified'
+    old_config_hash: str
+    new_config_hash: str
+    changes_summary: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "arn": self.resource.arn,
+            "resource_type": self.resource.resource_type,
+            "name": self.resource.name,
+            "region": self.resource.region,
+            "change_type": self.change_type,
+            "tags": self.resource.tags,
+            "old_config_hash": self.old_config_hash,
+            "new_config_hash": self.new_config_hash,
+            "changes_summary": self.changes_summary,
+        }
+
+
+@dataclass
+class DeltaReport:
+    """Represents differences between two snapshots."""
+
+    generated_at: datetime
+    baseline_snapshot_name: str  # Reference snapshot name (keeping field name for compatibility)
+    current_snapshot_name: str
+    added_resources: List[Any] = field(default_factory=list)  # List[Resource]
+    deleted_resources: List[Any] = field(default_factory=list)  # List[Resource]
+    modified_resources: List[ResourceChange] = field(default_factory=list)
+    baseline_resource_count: int = 0  # Reference snapshot count (keeping field name for compatibility)
+    current_resource_count: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "generated_at": self.generated_at.isoformat(),
+            "baseline_snapshot_name": self.baseline_snapshot_name,
+            "current_snapshot_name": self.current_snapshot_name,
+            "added_resources": [r.to_dict() for r in self.added_resources],
+            "deleted_resources": [r.to_dict() for r in self.deleted_resources],
+            "modified_resources": [r.to_dict() for r in self.modified_resources],
+            "baseline_resource_count": self.baseline_resource_count,
+            "current_resource_count": self.current_resource_count,
+            "summary": {
+                "added": len(self.added_resources),
+                "deleted": len(self.deleted_resources),
+                "modified": len(self.modified_resources),
+                "unchanged": self.unchanged_count,
+                "total_changes": self.total_changes,
+            },
+        }
+
+    @property
+    def total_changes(self) -> int:
+        """Total number of changes detected."""
+        return len(self.added_resources) + len(self.deleted_resources) + len(self.modified_resources)
+
+    @property
+    def unchanged_count(self) -> int:
+        """Number of unchanged resources."""
+        # Resources that existed in reference snapshot and still exist unchanged
+        return self.baseline_resource_count - len(self.deleted_resources) - len(self.modified_resources)
+
+    @property
+    def has_changes(self) -> bool:
+        """Whether any changes were detected."""
+        return self.total_changes > 0
+
+    def group_by_service(self) -> Dict[str, Dict[str, List]]:
+        """Group changes by service type.
+
+        Returns:
+            Dictionary mapping service type to changes dict with 'added', 'deleted', 'modified' lists
+        """
+        from typing import Any, Dict, List
+
+        grouped: Dict[str, Dict[str, List[Any]]] = {}
+
+        for resource in self.added_resources:
+            service = resource.resource_type
+            if service not in grouped:
+                grouped[service] = {"added": [], "deleted": [], "modified": []}
+            grouped[service]["added"].append(resource)
+
+        for resource in self.deleted_resources:
+            service = resource.resource_type
+            if service not in grouped:
+                grouped[service] = {"added": [], "deleted": [], "modified": []}
+            grouped[service]["deleted"].append(resource)
+
+        for change in self.modified_resources:
+            service = change.resource.resource_type
+            if service not in grouped:
+                grouped[service] = {"added": [], "deleted": [], "modified": []}
+            grouped[service]["modified"].append(change)
+
+        return grouped