reverse-diagrams 1.3.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

src/models.py

@@ -0,0 +1,242 @@
+"""Data models with validation for AWS resources."""
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+from enum import Enum
+import re
+
+
+class PrincipalType(Enum):
+    """Principal types for account assignments."""
+    USER = "USER"
+    GROUP = "GROUP"
+
+
+class AccountStatus(Enum):
+    """AWS account status."""
+    ACTIVE = "ACTIVE"
+    SUSPENDED = "SUSPENDED"
+    PENDING_CLOSURE = "PENDING_CLOSURE"
+
+
+@dataclass
+class AWSAccount:
+    """AWS Account model with validation."""
+    id: str
+    name: str
+    email: str
+    status: AccountStatus = AccountStatus.ACTIVE
+    
+    def __post_init__(self):
+        """Validate account data after initialization."""
+        if not self.id or not self.id.isdigit() or len(self.id) != 12:
+            raise ValueError(f"Invalid AWS account ID: {self.id}. Must be 12 digits.")
+        
+        if not self.name or len(self.name.strip()) == 0:
+            raise ValueError("Account name cannot be empty.")
+        
+        if not self._is_valid_email(self.email):
+            raise ValueError(f"Invalid email format: {self.email}")
+    
+    @staticmethod
+    def _is_valid_email(email: str) -> bool:
+        """Validate email format."""
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        return bool(re.match(pattern, email))
+
+
+@dataclass
+class OrganizationalUnit:
+    """Organizational Unit model."""
+    id: str
+    name: str
+    parent_id: Optional[str] = None
+    accounts: List[AWSAccount] = None
+    child_ous: List['OrganizationalUnit'] = None
+    
+    def __post_init__(self):
+        """Initialize collections if None."""
+        if self.accounts is None:
+            self.accounts = []
+        if self.child_ous is None:
+            self.child_ous = []
+        
+        if not self.id or not self.id.startswith('ou-'):
+            raise ValueError(f"Invalid OU ID format: {self.id}")
+        
+        if not self.name or len(self.name.strip()) == 0:
+            raise ValueError("OU name cannot be empty.")
+
+
+@dataclass
+class AWSOrganization:
+    """AWS Organization model."""
+    id: str
+    master_account_id: str
+    feature_set: str
+    root_id: str
+    organizational_units: List[OrganizationalUnit] = None
+    accounts: List[AWSAccount] = None
+    
+    def __post_init__(self):
+        """Initialize collections if None."""
+        if self.organizational_units is None:
+            self.organizational_units = []
+        if self.accounts is None:
+            self.accounts = []
+        
+        if not self.master_account_id.isdigit() or len(self.master_account_id) != 12:
+            raise ValueError(f"Invalid master account ID: {self.master_account_id}")
+
+
+@dataclass
+class IdentityStoreUser:
+    """Identity Store User model."""
+    user_id: str
+    username: str
+    display_name: Optional[str] = None
+    email: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate user data."""
+        if not self.user_id:
+            raise ValueError("User ID cannot be empty.")
+        
+        if not self.username:
+            raise ValueError("Username cannot be empty.")
+        
+        if self.email and not AWSAccount._is_valid_email(self.email):
+            raise ValueError(f"Invalid email format: {self.email}")
+
+
+@dataclass
+class IdentityStoreGroup:
+    """Identity Store Group model."""
+    group_id: str
+    display_name: str
+    description: Optional[str] = None
+    members: List[IdentityStoreUser] = None
+    
+    def __post_init__(self):
+        """Initialize members if None."""
+        if self.members is None:
+            self.members = []
+        
+        if not self.group_id:
+            raise ValueError("Group ID cannot be empty.")
+        
+        if not self.display_name:
+            raise ValueError("Group display name cannot be empty.")
+
+
+@dataclass
+class PermissionSet:
+    """Permission Set model."""
+    arn: str
+    name: str
+    description: Optional[str] = None
+    session_duration: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate permission set data."""
+        if not self.arn or not self.arn.startswith('arn:aws:sso:::permissionSet/'):
+            raise ValueError(f"Invalid permission set ARN: {self.arn}")
+        
+        if not self.name:
+            raise ValueError("Permission set name cannot be empty.")
+
+
+@dataclass
+class AccountAssignment:
+    """Account Assignment model."""
+    account_id: str
+    permission_set_arn: str
+    principal_type: PrincipalType
+    principal_id: str
+    principal_name: Optional[str] = None
+    permission_set_name: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate assignment data."""
+        if not self.account_id.isdigit() or len(self.account_id) != 12:
+            raise ValueError(f"Invalid account ID: {self.account_id}")
+        
+        if not self.permission_set_arn.startswith('arn:aws:sso:::permissionSet/'):
+            raise ValueError(f"Invalid permission set ARN: {self.permission_set_arn}")
+        
+        if not self.principal_id:
+            raise ValueError("Principal ID cannot be empty.")
+
+
+@dataclass
+class DiagramConfig:
+    """Configuration for diagram generation."""
+    title: str
+    direction: str = "TB"  # Top to Bottom
+    show_labels: bool = True
+    output_format: str = "png"
+    output_path: Optional[str] = None
+    
+    def __post_init__(self):
+        """Validate diagram configuration."""
+        valid_directions = ["TB", "BT", "LR", "RL"]
+        if self.direction not in valid_directions:
+            raise ValueError(f"Invalid direction: {self.direction}. Must be one of {valid_directions}")
+        
+        valid_formats = ["png", "svg", "pdf"]
+        if self.output_format not in valid_formats:
+            raise ValueError(f"Invalid output format: {self.output_format}. Must be one of {valid_formats}")
+
+
+def validate_aws_response(response: Dict[str, Any], required_keys: List[str]) -> None:
+    """
+    Validate AWS API response contains required keys.
+    
+    Args:
+        response: AWS API response dictionary
+        required_keys: List of required keys
+        
+    Raises:
+        ValueError: If required keys are missing
+    """
+    missing_keys = [key for key in required_keys if key not in response]
+    if missing_keys:
+        raise ValueError(f"AWS response missing required keys: {missing_keys}")
+
+
+def sanitize_name_for_diagram(name: str) -> str:
+    """
+    Sanitize name for use in diagram generation.
+    
+    Args:
+        name: Original name
+        
+    Returns:
+        Sanitized name safe for diagram use
+    """
+    if not name:
+        return "Unknown"
+    
+    # Remove special characters and limit length
+    sanitized = re.sub(r'[^\w\s-]', '', name)
+    sanitized = re.sub(r'\s+', ' ', sanitized).strip()
+    
+    # Limit length and add line breaks for long names
+    if len(sanitized) > 20:
+        words = sanitized.split()
+        lines = []
+        current_line = ""
+        
+        for word in words:
+            if len(current_line + " " + word) <= 20:
+                current_line += " " + word if current_line else word
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+        
+        if current_line:
+            lines.append(current_line)
+        
+        sanitized = "\\n".join(lines[:3])  # Max 3 lines
+    
+    return sanitized

src/plugins/__init__.py

@@ -0,0 +1,12 @@
+"""Plugin system for Reverse Diagrams."""
+
+from .base import AWSServicePlugin, PluginManager
+from .registry import get_plugin_manager, register_plugin, discover_plugins
+
+__all__ = [
+    'AWSServicePlugin',
+    'PluginManager', 
+    'get_plugin_manager',
+    'register_plugin',
+    'discover_plugins'
+]

src/plugins/base.py

@@ -0,0 +1,292 @@
+"""Base plugin system for AWS service integrations."""
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional, Type
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..aws.client_manager import AWSClientManager
+from ..models import DiagramConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PluginMetadata:
+    """Metadata for a plugin."""
+    name: str
+    version: str
+    description: str
+    author: str
+    aws_services: List[str]  # AWS services this plugin supports
+    dependencies: List[str] = None  # Additional dependencies
+    
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+
+class AWSServicePlugin(ABC):
+    """Base class for AWS service plugins."""
+    
+    def __init__(self):
+        """Initialize the plugin."""
+        self._metadata: Optional[PluginMetadata] = None
+        self._client_manager: Optional[AWSClientManager] = None
+    
+    @property
+    @abstractmethod
+    def metadata(self) -> PluginMetadata:
+        """Get plugin metadata."""
+        pass
+    
+    @abstractmethod
+    def collect_data(self, client_manager: AWSClientManager, region: str, **kwargs) -> Dict[str, Any]:
+        """
+        Collect data from AWS services.
+        
+        Args:
+            client_manager: AWS client manager
+            region: AWS region
+            **kwargs: Additional parameters
+            
+        Returns:
+            Collected data dictionary
+        """
+        pass
+    
+    @abstractmethod
+    def generate_diagram_code(self, data: Dict[str, Any], config: DiagramConfig) -> str:
+        """
+        Generate diagram code from collected data.
+        
+        Args:
+            data: Data collected from AWS
+            config: Diagram configuration
+            
+        Returns:
+            Python code for generating diagram
+        """
+        pass
+    
+    def validate_data(self, data: Dict[str, Any]) -> bool:
+        """
+        Validate collected data.
+        
+        Args:
+            data: Data to validate
+            
+        Returns:
+            True if data is valid, False otherwise
+        """
+        return bool(data)  # Default implementation
+    
+    def get_required_permissions(self) -> List[str]:
+        """
+        Get list of required AWS permissions.
+        
+        Returns:
+            List of IAM permission strings
+        """
+        return []  # Default implementation
+    
+    def setup(self, client_manager: AWSClientManager) -> None:
+        """
+        Setup the plugin with client manager.
+        
+        Args:
+            client_manager: AWS client manager
+        """
+        self._client_manager = client_manager
+        logger.debug(f"Plugin {self.metadata.name} setup complete")
+    
+    def cleanup(self) -> None:
+        """Cleanup plugin resources."""
+        self._client_manager = None
+        logger.debug(f"Plugin {self.metadata.name} cleanup complete")
+
+
+class PluginManager:
+    """Manager for AWS service plugins."""
+    
+    def __init__(self):
+        """Initialize plugin manager."""
+        self._plugins: Dict[str, AWSServicePlugin] = {}
+        self._plugin_classes: Dict[str, Type[AWSServicePlugin]] = {}
+        
+    def register_plugin(self, plugin_class: Type[AWSServicePlugin]) -> None:
+        """
+        Register a plugin class.
+        
+        Args:
+            plugin_class: Plugin class to register
+        """
+        try:
+            # Create instance to get metadata
+            plugin_instance = plugin_class()
+            metadata = plugin_instance.metadata
+            
+            if metadata.name in self._plugin_classes:
+                logger.warning(f"Plugin {metadata.name} is already registered, overriding")
+            
+            self._plugin_classes[metadata.name] = plugin_class
+            logger.debug(f"Registered plugin: {metadata.name} v{metadata.version}")
+            
+        except Exception as e:
+            logger.error(f"Failed to register plugin {plugin_class.__name__}: {e}")
+            raise
+    
+    def load_plugin(self, plugin_name: str, client_manager: AWSClientManager) -> AWSServicePlugin:
+        """
+        Load and setup a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to load
+            client_manager: AWS client manager
+            
+        Returns:
+            Loaded plugin instance
+            
+        Raises:
+            ValueError: If plugin is not found
+        """
+        if plugin_name not in self._plugin_classes:
+            raise ValueError(f"Plugin {plugin_name} not found. Available: {list(self._plugin_classes.keys())}")
+        
+        if plugin_name in self._plugins:
+            logger.debug(f"Plugin {plugin_name} already loaded")
+            return self._plugins[plugin_name]
+        
+        try:
+            plugin_class = self._plugin_classes[plugin_name]
+            plugin_instance = plugin_class()
+            plugin_instance.setup(client_manager)
+            
+            self._plugins[plugin_name] = plugin_instance
+            logger.debug(f"Loaded plugin: {plugin_name}")
+            
+            return plugin_instance
+            
+        except Exception as e:
+            logger.error(f"Failed to load plugin {plugin_name}: {e}")
+            raise
+    
+    def unload_plugin(self, plugin_name: str) -> None:
+        """
+        Unload a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to unload
+        """
+        if plugin_name in self._plugins:
+            plugin = self._plugins[plugin_name]
+            plugin.cleanup()
+            del self._plugins[plugin_name]
+            logger.debug(f"Unloaded plugin: {plugin_name}")
+    
+    def get_plugin(self, plugin_name: str) -> Optional[AWSServicePlugin]:
+        """
+        Get a loaded plugin.
+        
+        Args:
+            plugin_name: Name of the plugin
+            
+        Returns:
+            Plugin instance if loaded, None otherwise
+        """
+        return self._plugins.get(plugin_name)
+    
+    def list_available_plugins(self) -> List[PluginMetadata]:
+        """
+        List all available plugins.
+        
+        Returns:
+            List of plugin metadata
+        """
+        metadata_list = []
+        for plugin_class in self._plugin_classes.values():
+            try:
+                instance = plugin_class()
+                metadata_list.append(instance.metadata)
+            except Exception as e:
+                logger.warning(f"Failed to get metadata for plugin {plugin_class.__name__}: {e}")
+        
+        return metadata_list
+    
+    def list_loaded_plugins(self) -> List[str]:
+        """
+        List names of loaded plugins.
+        
+        Returns:
+            List of loaded plugin names
+        """
+        return list(self._plugins.keys())
+    
+    def get_plugins_for_service(self, aws_service: str) -> List[AWSServicePlugin]:
+        """
+        Get all loaded plugins that support a specific AWS service.
+        
+        Args:
+            aws_service: AWS service name
+            
+        Returns:
+            List of plugins supporting the service
+        """
+        matching_plugins = []
+        
+        for plugin in self._plugins.values():
+            if aws_service in plugin.metadata.aws_services:
+                matching_plugins.append(plugin)
+        
+        return matching_plugins
+    
+    def cleanup_all(self) -> None:
+        """Cleanup all loaded plugins."""
+        for plugin_name in list(self._plugins.keys()):
+            self.unload_plugin(plugin_name)
+        
+        logger.debug("All plugins cleaned up")
+
+
+def discover_plugins_in_directory(directory: Path) -> List[Type[AWSServicePlugin]]:
+    """
+    Discover plugins in a directory.
+    
+    Args:
+        directory: Directory to search for plugins
+        
+    Returns:
+        List of discovered plugin classes
+    """
+    discovered_plugins = []
+    
+    if not directory.exists() or not directory.is_dir():
+        logger.debug(f"Plugin directory {directory} does not exist")
+        return discovered_plugins
+    
+    # Look for Python files in the directory
+    for plugin_file in directory.glob("*.py"):
+        if plugin_file.name.startswith("_"):
+            continue  # Skip private files
+        
+        try:
+            # Import the module dynamically
+            import importlib.util
+            spec = importlib.util.spec_from_file_location(plugin_file.stem, plugin_file)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                
+                # Look for plugin classes
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    if (isinstance(attr, type) and 
+                        issubclass(attr, AWSServicePlugin) and 
+                        attr != AWSServicePlugin):
+                        discovered_plugins.append(attr)
+                        logger.debug(f"Discovered plugin class: {attr.__name__} in {plugin_file}")
+                        
+        except Exception as e:
+            logger.warning(f"Failed to load plugin from {plugin_file}: {e}")
+    
+    return discovered_plugins

src/plugins/builtin/__init__.py

@@ -0,0 +1,12 @@
+"""Built-in plugins for Reverse Diagrams."""
+
+# Import all built-in plugins to ensure they're available for discovery
+from .ec2_plugin import EC2Plugin
+from .organizations_plugin import OrganizationsPlugin
+from .identity_center_plugin import IdentityCenterPlugin
+
+__all__ = [
+    'EC2Plugin',
+    'OrganizationsPlugin', 
+    'IdentityCenterPlugin'
+]