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

reverse_diagrams-2.0.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+src/__init__.py,sha256=lOE8TAJF_WdxgxEBxVz9t8dC3s3t2c21VWYPrzfznkE,17
+src/config.py,sha256=7KinPO7ybCc5IQKmz1OcT-oXF1TUQWlaIyNC2eW86bI,4980
+src/models.py,sha256=vFDPdKGxjxwdBN3O_-bnnF9TIqM3I3KTK7n2n9PaktY,7608
+src/reverse_diagrams.py,sha256=XFF3f1MoNDjtCYolj1SiDOYWlV5djD4Hq30NJw5gvbQ,16929
+src/version.py,sha256=tJk7e8Z_LpxGMdTvSeAHQ45G-1AEWVWBBqAqDg_KC9w,48
+src/aws/__init__.py,sha256=lOE8TAJF_WdxgxEBxVz9t8dC3s3t2c21VWYPrzfznkE,17
+src/aws/client_manager.py,sha256=rmDoGDsxZj7q0tYf9xot5pxOrN5cBnHBkRgbiLrerqU,8456
+src/aws/describe_identity_store.py,sha256=AA3GVz6UyKepImm6VL2nqkbyH13X8f40qn-zNhICEkw,15821
+src/aws/describe_organization.py,sha256=tqImKyLtftk5upgVQmordFmBO7M1NeIQg3-KwwiQhOA,12743
+src/aws/describe_sso.py,sha256=_wcyHr0xFLXicC6IJs7uaj26E6TXywiiwUjteStCI_M,6771
+src/aws/exceptions.py,sha256=QJqO3i5Q1BiwnX15RDkUWQoDA-6MnYsNP5d8Q6SKqbE,562
+src/banner/__init__.py,sha256=lOE8TAJF_WdxgxEBxVz9t8dC3s3t2c21VWYPrzfznkE,17
+src/banner/banner.py,sha256=QOhJ_qI0_0MWI5wo-IMFv_-nrPN4RuJRJSqPUq_uPF0,2101
+src/dgms/__init__.py,sha256=lOE8TAJF_WdxgxEBxVz9t8dC3s3t2c21VWYPrzfznkE,17
+src/dgms/graph_mapper.py,sha256=xutxzxLCIGSBfHCAF-BnWXN21bjzusA43ZhKtXUir2E,7714
+src/dgms/graph_template.py,sha256=IOEmTk9A0xqEhtdNnaFrVDJlBF0ggW0WpxosW4nbcQo,1217
+src/plugins/__init__.py,sha256=Oq17hXr9-BOlY60ZcbKbQaeMf2cabqJc6APdtqJ7Ylg,312
+src/plugins/base.py,sha256=wuLqqNibsAoJJacKI3pQwUFdzmhbXBm__U60_xyRDKA,9533
+src/plugins/registry.py,sha256=R4IpEnis9wr5GUREAb3Rqi2X-4OBY41kvynGxg0doSo,3957
+src/plugins/builtin/__init__.py,sha256=u06O_XAREbZ1BxvYp1d-2stD3iELpA_pTll3j5-b5Jw,360
+src/plugins/builtin/ec2_plugin.py,sha256=BgLANn7sTN0m9Rs0gHnA-5mtPJL1V-tQmr7JnUtac38,8958
+src/plugins/builtin/identity_center_plugin.py,sha256=9IKTEFAaluuePoED2jhwtLAL0_fjbcP72TEmRQCXpJ8,22141
+src/plugins/builtin/organizations_plugin.py,sha256=4dYGCL4kvJ_ZAa9D_-6fRS6u0mqUr8hzalr-sRna1CE,15319
+src/reports/__init__.py,sha256=lOE8TAJF_WdxgxEBxVz9t8dC3s3t2c21VWYPrzfznkE,17
+src/reports/console_view.py,sha256=-zR8fd7h2lLwqjIIs8TMzl0r8Q1k3ZWt5xrtEhN9KNc,7997
+src/reports/save_results.py,sha256=35KOP6R3t5DBWQDPdQy5agEODPQBTPnwe22M7-HfOJA,7004
+src/utils/__init__.py,sha256=2qVZjBvUSXJngCvc68FnhAOJTA2RiW-AWc6HhxQX-ak,43
+src/utils/cache.py,sha256=fZ5b0rgeETNeaJW19hHClkQwEiohF4hvLr1nxuPSqXQ,8711
+src/utils/concurrent.py,sha256=6haOaH7IGeCLHyGlxkMrOYEuaA471k2ncHr3VtNXhNU,12230
+src/utils/progress.py,sha256=j9e6-axDloIn8C5UL1CLVqlw4nQbKe7gK1Mjd_e0Wdk,7996
+reverse_diagrams-2.0.0.dist-info/METADATA,sha256=L0RTnQsLw-WlLlEnHHjrS3FuZXvormP9aqwCr2yrxvg,23889
+reverse_diagrams-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+reverse_diagrams-2.0.0.dist-info/entry_points.txt,sha256=VZNkrc7qUDbddTCH3pGd83EhUT3PHTx9MzpAk6bb6qc,63
+reverse_diagrams-2.0.0.dist-info/licenses/LICENSE,sha256=o6nDaQ7M9xbR0L7HSJ3A-1JbBPoZro_zhVPO4-M5CAQ,571
+reverse_diagrams-2.0.0.dist-info/RECORD,,

{reverse_diagrams-1.3.4.dist-info → reverse_diagrams-2.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

src/aws/client_manager.py

@@ -0,0 +1,217 @@
+"""AWS Client Manager with proper error handling and validation."""
+import logging
+from functools import wraps
+from typing import Optional, Dict, Any
+import time
+
+import boto3
+from botocore.exceptions import (
+    ClientError, 
+    NoCredentialsError, 
+    PartialCredentialsError,
+    BotoCoreError
+)
+
+from .exceptions import (
+    AWSCredentialsError,
+    AWSPermissionError,
+    AWSServiceError,
+    AWSResourceNotFoundError
+)
+
+logger = logging.getLogger(__name__)
+
+
+def retry_with_backoff(max_retries: int = 3, backoff_factor: float = 2.0):
+    """Decorator to retry AWS API calls with exponential backoff."""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except ClientError as e:
+                    error_code = e.response.get('Error', {}).get('Code', '')
+                    
+                    # Retry on throttling errors
+                    if error_code in ['Throttling', 'TooManyRequestsException', 'RequestLimitExceeded']:
+                        if attempt < max_retries - 1:
+                            sleep_time = backoff_factor ** attempt
+                            logger.warning(f"AWS API throttled, retrying in {sleep_time}s (attempt {attempt + 1}/{max_retries})")
+                            time.sleep(sleep_time)
+                            continue
+                    
+                    # Don't retry on other errors
+                    raise AWSServiceError(f"AWS API error: {e}")
+                except BotoCoreError as e:
+                    raise AWSServiceError(f"AWS service error: {e}")
+            
+            # Final attempt without retry
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+class AWSClientManager:
+    """Manages AWS clients with proper error handling and validation."""
+    
+    def __init__(self, region: str, profile: Optional[str] = None):
+        """
+        Initialize AWS client manager.
+        
+        Args:
+            region: AWS region name
+            profile: AWS CLI profile name (optional)
+        """
+        self.region = region
+        self.profile = profile
+        self._session = None
+        self._clients: Dict[str, Any] = {}
+        
+        self._setup_session()
+        self._validate_credentials()
+    
+    def _setup_session(self):
+        """Setup boto3 session with profile if provided."""
+        try:
+            if self.profile:
+                self._session = boto3.Session(profile_name=self.profile)
+                logger.info(f"Using AWS profile: {self.profile}")
+            else:
+                self._session = boto3.Session()
+                logger.info("Using default AWS credentials")
+        except Exception as e:
+            raise AWSCredentialsError(f"Failed to setup AWS session: {e}")
+    
+    def _validate_credentials(self):
+        """Validate AWS credentials by making a test call."""
+        try:
+            sts_client = self.get_client('sts')
+            identity = sts_client.get_caller_identity()
+            logger.info(f"AWS credentials validated for account: {identity.get('Account')}")
+        except NoCredentialsError:
+            raise AWSCredentialsError("No AWS credentials found. Please configure AWS CLI or set environment variables.")
+        except PartialCredentialsError:
+            raise AWSCredentialsError("Incomplete AWS credentials. Please check your configuration.")
+        except ClientError as e:
+            error_code = e.response.get('Error', {}).get('Code', '')
+            if error_code in ['AccessDenied', 'UnauthorizedOperation']:
+                raise AWSPermissionError(f"Insufficient AWS permissions: {e}")
+            raise AWSCredentialsError(f"AWS credential validation failed: {e}")
+    
+    def get_client(self, service_name: str, **kwargs):
+        """
+        Get AWS client for specified service with caching.
+        
+        Args:
+            service_name: AWS service name (e.g., 'organizations', 'sso-admin')
+            **kwargs: Additional client configuration
+            
+        Returns:
+            Boto3 client instance
+        """
+        client_key = f"{service_name}_{self.region}"
+        
+        if client_key not in self._clients:
+            try:
+                self._clients[client_key] = self._session.client(
+                    service_name,
+                    region_name=self.region,
+                    **kwargs
+                )
+                logger.debug(f"Created {service_name} client for region {self.region}")
+            except Exception as e:
+                raise AWSServiceError(f"Failed to create {service_name} client: {e}")
+        
+        return self._clients[client_key]
+    
+    @retry_with_backoff()
+    def call_api(self, service_name: str, method_name: str, **kwargs):
+        """
+        Make AWS API call with error handling and retry logic.
+        
+        Args:
+            service_name: AWS service name
+            method_name: API method name
+            **kwargs: Method parameters
+            
+        Returns:
+            API response
+        """
+        try:
+            client = self.get_client(service_name)
+            method = getattr(client, method_name)
+            response = method(**kwargs)
+            logger.debug(f"Successfully called {service_name}.{method_name}")
+            return response
+        except AttributeError:
+            raise AWSServiceError(f"Method {method_name} not found for service {service_name}")
+        except ClientError as e:
+            error_code = e.response.get('Error', {}).get('Code', '')
+            
+            if error_code in ['ResourceNotFoundException', 'NoSuchEntity']:
+                raise AWSResourceNotFoundError(f"AWS resource not found: {e}")
+            elif error_code in ['AccessDenied', 'UnauthorizedOperation']:
+                raise AWSPermissionError(f"Insufficient permissions for {service_name}.{method_name}: {e}")
+            else:
+                raise AWSServiceError(f"AWS API call failed {service_name}.{method_name}: {e}")
+    
+    def paginate_api_call(self, service_name: str, method_name: str, result_key: str, **kwargs):
+        """
+        Handle paginated AWS API calls.
+        
+        Args:
+            service_name: AWS service name
+            method_name: API method name
+            result_key: Key in response containing the results
+            **kwargs: Method parameters
+            
+        Returns:
+            List of all results from paginated calls
+        """
+        try:
+            client = self.get_client(service_name)
+            paginator = client.get_paginator(method_name)
+            
+            all_results = []
+            for page in paginator.paginate(**kwargs):
+                if result_key in page:
+                    all_results.extend(page[result_key])
+            
+            logger.info(f"Retrieved {len(all_results)} items from paginated {service_name}.{method_name}")
+            return all_results
+            
+        except ClientError as e:
+            raise AWSServiceError(f"Paginated API call failed {service_name}.{method_name}: {e}")
+        except Exception as e:
+            raise AWSServiceError(f"Pagination error for {service_name}.{method_name}: {e}")
+
+
+# Global client manager instance
+_client_manager: Optional[AWSClientManager] = None
+
+
+def get_client_manager(region: str, profile: Optional[str] = None) -> AWSClientManager:
+    """Get or create global client manager instance."""
+    global _client_manager
+    
+    if _client_manager is None or _client_manager.region != region or _client_manager.profile != profile:
+        _client_manager = AWSClientManager(region=region, profile=profile)
+    
+    return _client_manager
+
+
+def client(service_name: str, region_name: str, profile: Optional[str] = None):
+    """
+    Backward compatibility function for existing code.
+    
+    Args:
+        service_name: AWS service name
+        region_name: AWS region
+        profile: AWS profile (optional)
+        
+    Returns:
+        Boto3 client instance
+    """
+    manager = get_client_manager(region=region_name, profile=profile)
+    return manager.get_client(service_name)

src/aws/describe_identity_store.py

@@ -406,6 +406,14 @@ def graph_identity_center(diagrams_path, region, auto):
         + emoji.emojize(":sparkle: Getting Identity store instance info" + Fore.RESET)
     )
     logging.debug(store_instances)
+    
+    # Check if IAM Identity Center is enabled
+    if not store_instances or len(store_instances) == 0:
+        error_msg = "No IAM Identity Center (SSO) instances found. Please enable IAM Identity Center in your AWS account."
+        print(Fore.RED + f"❌ {error_msg}" + Fore.RESET)
+        logging.error(error_msg)
+        raise ValueError(error_msg)
+    
     store_id = store_instances[0]["IdentityStoreId"]
     store_arn = store_instances[0]["InstanceArn"]