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

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/deletion_operation.py

@@ -0,0 +1,104 @@
+"""Deletion operation model.
+
+Represents a complete restore operation with metadata, filters, and execution context.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class OperationMode(Enum):
+    """Operation execution mode."""
+
+    DRY_RUN = "dry-run"
+    EXECUTE = "execute"
+
+
+class OperationStatus(Enum):
+    """Operation execution status with state transitions."""
+
+    PLANNED = "planned"
+    EXECUTING = "executing"
+    COMPLETED = "completed"
+    PARTIAL = "partial"
+    FAILED = "failed"
+
+
+@dataclass
+class DeletionOperation:
+    """Deletion operation entity.
+
+    Represents a complete restore operation with metadata, filters, and execution
+    context. Tracks overall progress and status of resource deletion.
+
+    State transitions:
+        planned → executing → completed (all succeeded)
+        planned → executing → partial (some failed)
+        planned → executing → failed (critical error)
+
+    Attributes:
+        operation_id: Unique identifier for the operation
+        baseline_snapshot: Name of baseline snapshot to compare against
+        timestamp: When operation was initiated (ISO 8601 UTC)
+        account_id: AWS account ID (12-digit number)
+        mode: dry-run or execute
+        status: Current execution status
+        total_resources: Total resources identified for deletion
+        succeeded_count: Number successfully deleted (default: 0)
+        failed_count: Number that failed to delete (default: 0)
+        skipped_count: Number skipped due to protections (default: 0)
+        aws_profile: AWS profile used for credentials (optional)
+        filters: Resource type and region filters (optional)
+        started_at: When execution started (optional, execute mode only)
+        completed_at: When execution completed (optional)
+        duration_seconds: Total execution duration (optional)
+    """
+
+    operation_id: str
+    baseline_snapshot: str
+    timestamp: datetime
+    account_id: str
+    mode: OperationMode
+    status: OperationStatus
+    total_resources: int
+    succeeded_count: int = 0
+    failed_count: int = 0
+    skipped_count: int = 0
+    aws_profile: Optional[str] = None
+    filters: Optional[dict] = field(default=None)
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    duration_seconds: Optional[float] = None
+
+    def validate(self) -> bool:
+        """Validate operation invariants.
+
+        Validation rules:
+            - succeeded_count + failed_count + skipped_count == total_resources
+            - completed_at must be after started_at
+            - dry-run mode must have planned status
+
+        Returns:
+            True if validation passes
+
+        Raises:
+            ValueError: If any validation rule fails
+        """
+        # Count validation
+        if self.succeeded_count + self.failed_count + self.skipped_count != self.total_resources:
+            raise ValueError("Resource counts don't match total")
+
+        # Timing validation
+        if self.completed_at and self.started_at:
+            if self.completed_at < self.started_at:
+                raise ValueError("Completion time before start time")
+
+        # Mode/status consistency
+        if self.mode == OperationMode.DRY_RUN and self.status != OperationStatus.PLANNED:
+            raise ValueError("Dry-run mode must have planned status")
+
+        return True

src/models/deletion_record.py

@@ -0,0 +1,97 @@
+"""Deletion record model.
+
+Individual resource deletion attempt with result and metadata.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class DeletionStatus(Enum):
+    """Individual resource deletion status."""
+
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class DeletionRecord:
+    """Deletion record entity.
+
+    Represents an individual resource deletion attempt with result and metadata.
+    Each record belongs to a DeletionOperation and tracks the outcome for a single
+    resource.
+
+    Validation rules:
+        - status=succeeded: no error_code or protection_reason
+        - status=failed: requires error_code
+        - status=skipped: requires protection_reason
+        - resource_arn must start with "arn:aws:"
+        - estimated_monthly_cost must be >= 0 if provided
+
+    Attributes:
+        record_id: Unique identifier for this record
+        operation_id: Parent operation identifier
+        resource_arn: AWS Resource Name (ARN format)
+        resource_id: Resource identifier (ID, name)
+        resource_type: AWS resource type (format: aws:service:type)
+        region: AWS region
+        timestamp: When deletion was attempted (ISO 8601 UTC)
+        status: Deletion outcome (succeeded, failed, skipped)
+        error_code: AWS error code if failed (optional)
+        error_message: Human-readable error if failed (optional)
+        protection_reason: Why resource was skipped (optional)
+        deletion_tier: Tier (1-5) for deletion ordering (optional)
+        tags: Resource tags at deletion time (optional)
+        estimated_monthly_cost: Estimated cost in USD (optional)
+    """
+
+    record_id: str
+    operation_id: str
+    resource_arn: str
+    resource_id: str
+    resource_type: str
+    region: str
+    timestamp: datetime
+    status: DeletionStatus
+    error_code: Optional[str] = None
+    error_message: Optional[str] = None
+    protection_reason: Optional[str] = None
+    deletion_tier: Optional[int] = None
+    tags: Optional[dict] = field(default=None)
+    estimated_monthly_cost: Optional[float] = None
+
+    def validate(self) -> bool:
+        """Validate record invariants.
+
+        Returns:
+            True if validation passes
+
+        Raises:
+            ValueError: If any validation rule fails
+        """
+        # Status-specific validation
+        if self.status == DeletionStatus.FAILED:
+            if not self.error_code:
+                raise ValueError("Failed status requires error_code")
+        elif self.status == DeletionStatus.SKIPPED:
+            if not self.protection_reason:
+                raise ValueError("Skipped status requires protection_reason")
+        elif self.status == DeletionStatus.SUCCEEDED:
+            if self.error_code or self.protection_reason:
+                raise ValueError("Succeeded status cannot have error or protection reason")
+
+        # ARN format validation
+        if not self.resource_arn.startswith("arn:aws:"):
+            raise ValueError("Invalid ARN format")
+
+        # Cost validation
+        if self.estimated_monthly_cost is not None and self.estimated_monthly_cost < 0:
+            raise ValueError("Cost cannot be negative")
+
+        return True

src/models/delta_report.py

@@ -0,0 +1,122 @@
+"""Delta report models for tracking resource changes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from ..delta.models import DriftReport
+
+
+@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
+    drift_report: Optional[DriftReport] = None  # Configuration drift details (when --show-diff is used)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        result = {
+            "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,
+            },
+        }
+
+        # Include drift details if available
+        if self.drift_report is not None:
+            result["drift_details"] = self.drift_report.to_dict()
+
+        return result
+
+    @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
+        """
+
+        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

src/models/efs_resource.py

@@ -0,0 +1,80 @@
+"""EFS resource model."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from ..utils.hash import compute_config_hash
+
+
+@dataclass
+class EFSFileSystem:
+    """Represents an AWS EFS file system."""
+
+    file_system_id: str
+    arn: str
+    encryption_enabled: bool
+    kms_key_id: Optional[str]
+    performance_mode: str  # "generalPurpose" or "maxIO"
+    lifecycle_state: str  # "available", "creating", "deleting", "deleted"
+    tags: Dict[str, str]
+    region: str
+    created_at: datetime
+
+    def validate(self) -> bool:
+        """Validate EFS file system data.
+
+        Returns:
+            True if valid, raises ValueError if invalid
+        """
+        # Validate file_system_id format (must start with fs-)
+        if not re.match(r"^fs-[a-fA-F0-9]+$", self.file_system_id):
+            raise ValueError(f"Invalid file_system_id format: {self.file_system_id}. Must match pattern: fs-*")
+
+        # Validate performance_mode
+        valid_performance_modes = ["generalPurpose", "maxIO"]
+        if self.performance_mode not in valid_performance_modes:
+            raise ValueError(
+                f"Invalid performance_mode: {self.performance_mode}. "
+                f"Must be one of: {', '.join(valid_performance_modes)}"
+            )
+
+        # Validate lifecycle_state
+        valid_states = ["available", "creating", "deleting", "deleted"]
+        if self.lifecycle_state not in valid_states:
+            raise ValueError(
+                f"Invalid lifecycle_state: {self.lifecycle_state}. " f"Must be one of: {', '.join(valid_states)}"
+            )
+
+        return True
+
+    def to_resource_dict(self) -> Dict[str, Any]:
+        """Convert to Resource-compatible dictionary.
+
+        Returns:
+            Dictionary that can be used to create a Resource object
+        """
+        # Build raw_config with all EFS-specific attributes
+        raw_config = {
+            "file_system_id": self.file_system_id,
+            "arn": self.arn,
+            "encryption_enabled": self.encryption_enabled,
+            "kms_key_id": self.kms_key_id,
+            "performance_mode": self.performance_mode,
+            "lifecycle_state": self.lifecycle_state,
+            "region": self.region,
+        }
+
+        return {
+            "arn": self.arn,
+            "resource_type": "efs:file-system",
+            "name": self.file_system_id,
+            "region": self.region,
+            "tags": self.tags,
+            "created_at": self.created_at,
+            "raw_config": raw_config,
+            "config_hash": compute_config_hash(raw_config),
+        }

src/models/elasticache_resource.py

@@ -0,0 +1,90 @@
+"""ElastiCache resource model."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+from ..utils.hash import compute_config_hash
+
+
+@dataclass
+class ElastiCacheCluster:
+    """Represents an AWS ElastiCache cluster (Redis or Memcached).
+
+    This model captures both Redis and Memcached clusters with their
+    encryption settings, node configuration, and metadata.
+
+    Attributes:
+        cluster_id: Unique identifier for the cluster (max 50 chars)
+        arn: Amazon Resource Name for the cluster
+        engine: Cache engine type (redis or memcached)
+        node_type: Cache node type (e.g., cache.t3.micro)
+        num_cache_nodes: Number of cache nodes in the cluster
+        engine_version: Engine version string
+        encryption_at_rest: Whether data at rest is encrypted
+        encryption_in_transit: Whether data in transit is encrypted
+        tags: Resource tags as key-value pairs
+        region: AWS region
+    """
+
+    cluster_id: str
+    arn: str
+    engine: str
+    node_type: str
+    num_cache_nodes: int
+    engine_version: str
+    encryption_at_rest: bool
+    encryption_in_transit: bool
+    tags: Dict[str, str] = field(default_factory=dict)
+    region: str = "us-east-1"
+
+    def __post_init__(self) -> None:
+        """Validate ElastiCache cluster data after initialization."""
+        # Validate cluster_id length (AWS limit is 50 characters)
+        if len(self.cluster_id) > 50:
+            raise ValueError("cluster_id must be 50 characters or less")
+
+        # Validate engine type
+        if self.engine not in ("redis", "memcached"):
+            raise ValueError("engine must be 'redis' or 'memcached'")
+
+        # Memcached does not support encryption at rest
+        if self.engine == "memcached" and self.encryption_at_rest:
+            raise ValueError("Memcached does not support encryption at rest")
+
+        # Validate num_cache_nodes
+        if self.num_cache_nodes < 1:
+            raise ValueError("num_cache_nodes must be at least 1")
+
+    def to_resource_dict(self) -> Dict[str, Any]:
+        """Convert ElastiCache cluster to Resource dictionary.
+
+        Returns:
+            Dictionary with Resource fields suitable for creating a Resource object
+        """
+        # Build raw_config that matches ElastiCache API response structure
+        raw_config = {
+            "CacheClusterId": self.cluster_id,
+            "ARN": self.arn,
+            "Engine": self.engine,
+            "CacheNodeType": self.node_type,
+            "NumCacheNodes": self.num_cache_nodes,
+            "EngineVersion": self.engine_version,
+            "AtRestEncryptionEnabled": self.encryption_at_rest,
+            "TransitEncryptionEnabled": self.encryption_in_transit,
+            "CacheClusterStatus": "available",
+        }
+
+        # Compute config hash from raw_config
+        config_hash = compute_config_hash(raw_config)
+
+        return {
+            "arn": self.arn,
+            "resource_type": "elasticache:cluster",
+            "name": self.cluster_id,
+            "region": self.region,
+            "tags": self.tags,
+            "config_hash": config_hash,
+            "raw_config": raw_config,
+        }