runbooks 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

runbooks/inventory/list_config_recorders_delivery_channels.py

@@ -93,11 +93,11 @@ from time import time
 import Inventory_Modules
 from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import del_config_recorder_or_delivery_channel2, display_results, get_all_credentials
-from tqdm.auto import tqdm
+# Migrated to Rich.Progress - see rich_utils.py for enterprise UX standards
+# from tqdm.auto import tqdm
 
-init()
 __version__ = "2024.05.31"
 
 
@@ -409,7 +409,7 @@ def check_accounts_for_delivery_channels_and_config_recorders(CredentialList, fF
                     logging.info(
                         f"{ERASE_LINE}Finished finding items in account {c_account_credentials['AccountId']} in region {c_account_credentials['Region']} - {c_PlaceCount} / {c_PlacesToLook}"
                     )
-                    pbar.update()  # Update progress bar for operational visibility
+                    pbar.update(pbar_task, advance=1)  # Update Rich progress bar for operational visibility
                     self.queue.task_done()  # Mark queue item as completed
 
     # Initialize processing context and data structures for Config discovery
@@ -421,40 +421,50 @@ def check_accounts_for_delivery_channels_and_config_recorders(CredentialList, fF
 
     checkqueue = Queue()  # Queue for work distribution across worker threads
 
+    # Import Rich display utilities for professional progress tracking
+    from runbooks.common.rich_utils import create_progress_bar
+
     # Initialize progress tracking for operational visibility during Config discovery
-    pbar = tqdm(
-        desc=f"Finding config recorders / delivery channels from {len(AllCredentials)} accounts and regions",
-        total=len(AllCredentials),
-        unit=" accounts & regions",
-    )
+    with create_progress_bar() as progress:
+        task = progress.add_task(
+            f"[cyan]Finding config recorders / delivery channels from {len(AllCredentials)} accounts and regions...",
+            total=len(AllCredentials)
+        )
 
-    # Create and start worker thread pool for concurrent Config component discovery
-    for x in range(WorkerThreads):
-        worker = Find_Config_Recorders_and_Delivery_Channels(checkqueue)
-        # Daemon threads allow main thread exit even if workers are still processing
-        worker.daemon = True
-        worker.start()
-
-    # Queue Config discovery work items for worker thread processing
-    # Note: Credential list already includes regional context, eliminating need for nested region iteration
-    for credential in CredentialList:
-        logging.info(f"Connecting to account {credential['AccountId']} in region {credential['Region']}")
-        try:
-            # Queue account and region combination for worker thread processing
-            # Note: Tuple structure is critical for proper parameter expansion in worker threads
-            checkqueue.put((credential, fFixRun, fFragments, len(CredentialList), PlaceCount))
-        except ClientError as my_Error:
-            # Handle authorization failures with informative error messaging
-            if "AuthFailure" in str(my_Error):
-                logging.error(
-                    f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
-                )
-                logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
-                pass
+        # Make progress object available to worker threads via global (multi-threaded pattern)
+        global pbar
+        pbar = progress
+        global pbar_task
+        pbar_task = task
+
+        # Create and start worker thread pool for concurrent Config component discovery
+        for x in range(WorkerThreads):
+            worker = Find_Config_Recorders_and_Delivery_Channels(checkqueue)
+            # Daemon threads allow main thread exit even if workers are still processing
+            worker.daemon = True
+            worker.start()
+
+        # Queue Config discovery work items for worker thread processing
+        # Note: Credential list already includes regional context, eliminating need for nested region iteration
+        for credential in CredentialList:
+            logging.info(f"Connecting to account {credential['AccountId']} in region {credential['Region']}")
+            try:
+                # Queue account and region combination for worker thread processing
+                # Note: Tuple structure is critical for proper parameter expansion in worker threads
+                checkqueue.put((credential, fFixRun, fFragments, len(CredentialList), PlaceCount))
+            except ClientError as my_Error:
+                # Handle authorization failures with informative error messaging
+                if "AuthFailure" in str(my_Error):
+                    logging.error(
+                        f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
+                    )
+                    logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
+                    pass
+
+        # Wait for all worker threads to complete processing
+        checkqueue.join()
+        # Progress bar auto-closes when exiting context manager
 
-    # Wait for all worker threads to complete processing
-    checkqueue.join()
-    pbar.close()  # Close progress bar after completion
     return account_crs_and_dcs
 
 
@@ -619,7 +629,7 @@ if __name__ == "__main__":
         print()
         milestone_time1 = time()
         print(
-            f"{Fore.GREEN}\t\tFiguring out what regions are available to your accounts, and capturing credentials for all accounts in those regions took: {(milestone_time1 - begin_time):.3f} seconds{Fore.RESET}"
+            f"[green]\t\tFiguring out what regions are available to your accounts, and capturing credentials for all accounts in those regions took: {(milestone_time1 - begin_time):.3f} seconds"
         )
         print()
     print(f"Now running through all accounts and regions identified to find resources...")
@@ -631,7 +641,7 @@ if __name__ == "__main__":
         print()
         milestone_time2 = time()
         print(
-            f"{Fore.GREEN}\t\tChecking {len(AllCredentials)} places took: {(milestone_time2 - milestone_time1):.3f} seconds{Fore.RESET}"
+            f"[green]\t\tChecking {len(AllCredentials)} places took: {(milestone_time2 - milestone_time1):.3f} seconds"
         )
         print()
     cr = 0
@@ -650,7 +660,7 @@ if __name__ == "__main__":
         print()
         milestone_time3 = time()
         print(
-            f"{Fore.GREEN}\t\tSorting the list of places took: {(milestone_time3 - milestone_time2):.3f} seconds{Fore.RESET}"
+            f"[green]\t\tSorting the list of places took: {(milestone_time3 - milestone_time2):.3f} seconds"
         )
         print()
     display_results(all_sorted_config_recorders_and_delivery_channels, display_dict, None, pFilename)
@@ -675,7 +685,7 @@ if __name__ == "__main__":
 
     if pTiming:
         print(ERASE_LINE)
-        print(f"{Fore.GREEN}This whole script took {time() - begin_time:.3f} seconds{Fore.RESET}")
+        print(f"[green]This whole script took {time() - begin_time:.3f} seconds")
     print()
     print("Thank you for using this tool")
     print()

runbooks/inventory/list_ds_directories.py

@@ -60,11 +60,11 @@ from time import time
 
 from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import display_results, find_directories2, get_all_credentials
-from tqdm.auto import tqdm
+# Migrated to Rich.Progress - see rich_utils.py for enterprise UX standards
+# from tqdm.auto import tqdm
 
-init()
 __version__ = "2024.05.31"
 
 
@@ -193,54 +193,66 @@ def find_all_directories(f_credentials, f_fragments, f_exact):
     """
     AllDirectories = []  # Aggregated list for all discovered directories
 
+    # Import Rich display utilities for professional progress tracking
+    from runbooks.common.rich_utils import create_progress_bar
+
     # TODO: Need to use multi-threading here for improved performance
     # Sequential processing with progress tracking for operational visibility
-    for credential in tqdm(
-        f_credentials, desc=f"Looking through {len(f_credentials)} accounts and regions", unit="credentials"
-    ):
-        logging.info(f"{ERASE_LINE}Looking in account: {credential['AccountId']} in region {credential['Region']}")
-
-        # Skip failed credentials to avoid API errors
-        if not credential["Success"]:
-            continue
-
-        try:
-            # Discover directories using Directory Service API with fragment filtering
-            directories = find_directories2(credential, credential["Region"], f_fragments, f_exact)
-            logging.info(f"directories: {directories}")
-            logging.info(
-                f"{ERASE_LINE}Account: {credential['AccountId']} Region: {credential['Region']} Found {len(directories)} directories"
-            )
-
-            # Process and aggregate discovered directories with organizational context
-            if directories:
-                for directory in directories:
-                    # Enhance directory metadata with organizational and regional context
-                    # Available directory metadata includes:
-                    # - DirectoryName: Human-readable directory identifier
-                    # - DirectoryId: Unique AWS Directory Service identifier
-                    # - HomeRegion: Primary directory service region
-                    # - Status: Operational status (Active, Creating, etc.)
-                    # - Type: Directory type (SimpleAD, MicrosoftAD, etc.)
-                    # - Owner: Directory ownership context
-
-                    directory.update(
-                        {
-                            "MgmtAccount": credential["MgmtAccount"],  # Management account context
-                            "Region": credential["Region"],  # Regional deployment information
-                            "AccountId": credential["AccountId"],  # Account ownership details
-                        }
-                    )
-                    AllDirectories.append(directory)
-
-        except TypeError as my_Error:
-            # Handle type errors from malformed Directory Service API responses
-            logging.info(f"Error: {my_Error}")
-            continue
-        except ClientError as my_Error:
-            # Handle AWS API authorization failures with informative logging
-            if "AuthFailure" in str(my_Error):
-                logging.error(f"{ERASE_LINE} Account {credential['AccountId']} : Authorization Failure")
+    with create_progress_bar() as progress:
+        task = progress.add_task(
+            f"[cyan]Looking through {len(f_credentials)} accounts and regions...",
+            total=len(f_credentials)
+        )
+
+        for credential in f_credentials:
+            logging.info(f"Looking in account: {credential['AccountId']} in region {credential['Region']}")
+
+            # Skip failed credentials to avoid API errors
+            if not credential["Success"]:
+                progress.update(task, advance=1)
+                continue
+
+            try:
+                # Discover directories using Directory Service API with fragment filtering
+                directories = find_directories2(credential, credential["Region"], f_fragments, f_exact)
+                logging.info(f"directories: {directories}")
+                logging.info(
+                    f"Account: {credential['AccountId']} Region: {credential['Region']} Found {len(directories)} directories"
+                )
+
+                # Process and aggregate discovered directories with organizational context
+                if directories:
+                    for directory in directories:
+                        # Enhance directory metadata with organizational and regional context
+                        # Available directory metadata includes:
+                        # - DirectoryName: Human-readable directory identifier
+                        # - DirectoryId: Unique AWS Directory Service identifier
+                        # - HomeRegion: Primary directory service region
+                        # - Status: Operational status (Active, Creating, etc.)
+                        # - Type: Directory type (SimpleAD, MicrosoftAD, etc.)
+                        # - Owner: Directory ownership context
+
+                        directory.update(
+                            {
+                                "MgmtAccount": credential["MgmtAccount"],  # Management account context
+                                "Region": credential["Region"],  # Regional deployment information
+                                "AccountId": credential["AccountId"],  # Account ownership details
+                            }
+                        )
+                        AllDirectories.append(directory)
+
+            except TypeError as my_Error:
+                # Handle type errors from malformed Directory Service API responses
+                logging.info(f"Error: {my_Error}")
+                progress.update(task, advance=1)
+                continue
+            except ClientError as my_Error:
+                # Handle AWS API authorization failures with informative logging
+                if "AuthFailure" in str(my_Error):
+                    logging.error(f" Account {credential['AccountId']} : Authorization Failure")
+
+            # Update progress after processing each credential
+            progress.update(task, advance=1)
 
     return AllDirectories
 
@@ -293,7 +305,7 @@ if __name__ == "__main__":
     # Display credential retrieval timing for performance optimization
     if pTiming:
         print(
-            f"{Fore.GREEN}\tAfter getting credentials, this script took {time() - begin_time:.3f} seconds{Fore.RESET}"
+            f"[green]\tAfter getting credentials, this script took {time() - begin_time:.3f} seconds"
         )
         print()
 
@@ -304,7 +316,7 @@ if __name__ == "__main__":
     # Display credential parsing timing for operational metrics
     if pTiming:
         print(
-            f"{Fore.GREEN}\tAfter parsing out all Regions, Account and Profiles, this script took {time() - begin_time:.3f} seconds{Fore.RESET}"
+            f"[green]\tAfter parsing out all Regions, Account and Profiles, this script took {time() - begin_time:.3f} seconds"
         )
         print()
 
@@ -340,7 +352,7 @@ if __name__ == "__main__":
     display_results(sorted_Results, display_dict, "None")
 
     # Provide operational summary with discovery metrics and performance timing
-    print(ERASE_LINE)
+    console.print()
     print(
         f"Found {len(all_directories)} directories across {len(AccountList)} accounts across {len(RegionList)} regions"
     )
@@ -348,7 +360,7 @@ if __name__ == "__main__":
 
     # Display total execution timing for performance analysis and optimization
     if pTiming:
-        print(f"{Fore.GREEN}\tThis script took {time() - begin_time:.3f} seconds{Fore.RESET}")
+        print(f"[green]\tThis script took {time() - begin_time:.3f} seconds")
         print()
     print("Thank you for using this script")
     print()

runbooks/inventory/list_ec2_availability_zones.py

@@ -67,12 +67,10 @@ import sys
 from time import time
 
 from ArgumentsClass import CommonArguments
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import display_results, get_all_credentials, get_region_azs2
 
-init()
 __version__ = "2024.03.06"
-ERASE_LINE = "\x1b[2K"
 begin_time = time()
 
 
@@ -281,6 +279,6 @@ if __name__ == "__main__":
 
     print()
     if pTiming:
-        print(f"{Fore.GREEN}This script took {time() - begin_time:.2f} seconds{Fore.RESET}")
+        print(f"[green]This script took {time() - begin_time:.2f} seconds")
     print("Thanks for using this script")
     print()

runbooks/inventory/list_ec2_ebs_volumes.py

@@ -7,15 +7,13 @@ from time import time
 
 from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import display_results, find_account_volumes2, get_all_credentials
-from tqdm.auto import tqdm
+from runbooks.common.rich_utils import create_progress_bar
 
-init()
 __version__ = "2024.05.31"
 
 # ANSI escape code for clearing current line (progress bar cleanup)
-ERASE_LINE = "\x1b[2K"
 
 
 ##################
@@ -92,7 +90,7 @@ def present_results(fVolumesFound: list):
     # Calculate and display orphaned volumes
     orphaned_volumes = [vol for vol in de_dupe_VolumesFound if vol.get("State") == "available"]
     if orphaned_volumes:
-        print(f"{Fore.YELLOW}Warning: {len(orphaned_volumes)} orphaned (unattached) volumes found{Fore.RESET}")
+        print(f"[yellow]Warning: {len(orphaned_volumes)} orphaned (unattached) volumes found")
         total_orphaned_size = sum(vol.get("Size", 0) for vol in orphaned_volumes)
         print(f"Total orphaned storage: {total_orphaned_size} GB")
 
@@ -136,9 +134,9 @@ def check_accounts_for_ebs_volumes(f_CredentialList, f_fragment_list=None):
                     continue
                 finally:
                     logging.info(
-                        f"{ERASE_LINE}Finished finding EBS volumes in account {c_account_credentials['AccountId']} in region {c_account_credentials['Region']}"
+                        f"Finished finding EBS volumes in account {c_account_credentials['AccountId']} in region {c_account_credentials['Region']}"
                     )
-                    pbar.update()
+                    progress.update(task, advance=1)
                     self.queue.task_done()
 
     if f_fragment_list is None:
@@ -148,32 +146,31 @@ def check_accounts_for_ebs_volumes(f_CredentialList, f_fragment_list=None):
 
     checkqueue = Queue()
 
-    pbar = tqdm(
-        desc=f"Finding ebs volumes from {len(f_CredentialList)} accounts and regions",
-        total=len(f_CredentialList),
-        unit=" accounts & regions",
-    )
-
-    for x in range(WorkerThreads):
-        worker = FindVolumes(checkqueue)
-        # Setting daemon to True will let the main thread exit even though the workers are blocking
-        worker.daemon = True
-        worker.start()
-
-    for credential in f_CredentialList:
-        logging.info(f"Connecting to account {credential['AccountId']}")
-        try:
-            # print(f"{ERASE_LINE}Queuing account {credential['AccountId']} in region {region}", end='\r')
-            checkqueue.put((credential, credential["Region"], f_fragment_list))
-        except ClientError as my_Error:
-            if "AuthFailure" in str(my_Error):
-                logging.error(
-                    f"Authorization Failure accessing account {credential['AccountId']} in '{credential['Region']}' region"
-                )
-                logging.warning(f"It's possible that the region '{credential['Region']}' hasn't been opted-into")
-                pass
-    checkqueue.join()
-    pbar.close()
+    with create_progress_bar() as progress:
+        task = progress.add_task(
+            f"Finding ebs volumes from {len(f_CredentialList)} accounts and regions",
+            total=len(f_CredentialList)
+        )
+
+        for x in range(WorkerThreads):
+            worker = FindVolumes(checkqueue)
+            # Setting daemon to True will let the main thread exit even though the workers are blocking
+            worker.daemon = True
+            worker.start()
+
+        for credential in f_CredentialList:
+            logging.info(f"Connecting to account {credential['AccountId']}")
+            try:
+                # print(f"Queuing account {credential['AccountId']} in region {region}", end='\r')
+                checkqueue.put((credential, credential["Region"], f_fragment_list))
+            except ClientError as my_Error:
+                if "AuthFailure" in str(my_Error):
+                    logging.error(
+                        f"Authorization Failure accessing account {credential['AccountId']} in '{credential['Region']}' region"
+                    )
+                    logging.warning(f"It's possible that the region '{credential['Region']}' hasn't been opted-into")
+                    pass
+        checkqueue.join()
     return AllVolumes
 
 
@@ -231,8 +228,8 @@ def main():
 
     # Display execution timing if requested
     if pTiming:
-        print(ERASE_LINE)
-        print(f"{Fore.GREEN}This script completed in {time() - begin_time:.2f} seconds{Fore.RESET}")
+        console.print()
+        print(f"[green]This script completed in {time() - begin_time:.2f} seconds")
 
 
 if __name__ == "__main__":

runbooks/inventory/list_ec2_instances.py

@@ -62,13 +62,10 @@ from time import time
 from . import inventory_modules as Inventory_Modules
 from .ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
 from .inventory_modules import display_results, get_all_credentials
-from tqdm.auto import tqdm
+from runbooks.common.rich_utils import create_progress_bar
 
-init()
 __version__ = "2025.04.09"
-ERASE_LINE = "\x1b[2K"
 begin_time = time()
 
 
@@ -322,30 +319,28 @@ def find_all_instances(fAllCredentials: list, fStatus: str = None) -> list:
     AllInstances = []
     WorkerThreads = min(len(fAllCredentials), 25)
 
-    pbar = tqdm(
-        desc=f"Finding instances from {len(fAllCredentials)} locations", total=len(fAllCredentials), unit=" locations"
-    )
-
-    for x in range(WorkerThreads):
-        worker = FindInstances(checkqueue)
-        # Setting daemon to True will let the main thread exit even though the workers are blocking
-        worker.daemon = True
-        worker.start()
-
-    for credential in fAllCredentials:
-        logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
-        try:
-            # I don't know why - but double parens are necessary below. If you remove them, only the first parameter is queued.
-            checkqueue.put((credential))
-        except ClientError as my_Error:
-            if "AuthFailure" in str(my_Error):
-                logging.error(
-                    f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
-                )
-                logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
-                pass
-    checkqueue.join()
-    pbar.close()
+    with create_progress_bar() as progress:
+        task = progress.add_task(f"Finding instances from {len(fAllCredentials)} locations", total=len(fAllCredentials))
+
+        for x in range(WorkerThreads):
+            worker = FindInstances(checkqueue)
+            # Setting daemon to True will let the main thread exit even though the workers are blocking
+            worker.daemon = True
+            worker.start()
+
+        for credential in fAllCredentials:
+            logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
+            try:
+                # I don't know why - but double parens are necessary below. If you remove them, only the first parameter is queued.
+                checkqueue.put((credential))
+            except ClientError as my_Error:
+                if "AuthFailure" in str(my_Error):
+                    logging.error(
+                        f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
+                    )
+                    logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
+                    pass
+        checkqueue.join()
     return AllInstances
 
 

runbooks/inventory/list_ecs_clusters_and_tasks.py

@@ -90,13 +90,11 @@ from time import time
 import Inventory_Modules
 from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import display_results, find_account_ecs_clusters_services_and_tasks2, get_all_credentials
-from tqdm.auto import tqdm
+from runbooks.common.rich_utils import create_progress_bar
 
-init()
 __version__ = "2024.09.06"
-ERASE_LINE = "\x1b[2K"
 begin_time = time()
 
 # TODO: Need a table at the bottom that summarizes the results, by instance-type, by running/ stopped, maybe by account and region
@@ -246,7 +244,7 @@ def find_all_clusters_and_tasks(fAllCredentials: list, fStatus: str = None) -> l
             """
             while True:
                 # Retrieve ECS discovery work item from thread-safe queue
-                c_account_credentials = self.queue.get()
+                c_account_credentials, c_progress, c_task = self.queue.get()
                 logging.info(f"De-queued info for account number {c_account_credentials['AccountId']}")
 
                 try:
@@ -406,7 +404,7 @@ def find_all_clusters_and_tasks(fAllCredentials: list, fStatus: str = None) -> l
                         continue
                 finally:
                     # Ensure progress tracking and queue management regardless of success/failure
-                    pbar.update()
+                    c_progress.update(c_task, advance=1)
                     self.queue.task_done()
 
     ###########
@@ -423,13 +421,6 @@ def find_all_clusters_and_tasks(fAllCredentials: list, fStatus: str = None) -> l
     # Maximum 25 threads to prevent overwhelming AWS APIs while maintaining efficiency
     WorkerThreads = min(len(fAllCredentials), 25)
 
-    # Initialize progress tracking for operational visibility during large-scale operations
-    pbar = tqdm(
-        desc=f"Finding ECS clusters, services and tasks from {len(fAllCredentials)} accounts / regions",
-        total=len(fAllCredentials),
-        unit=" locations",
-    )
-
     # Start worker threads for concurrent ECS resource discovery
     for x in range(WorkerThreads):
         worker = FindInstances(checkqueue)
@@ -437,25 +428,26 @@ def find_all_clusters_and_tasks(fAllCredentials: list, fStatus: str = None) -> l
         worker.daemon = True
         worker.start()
 
-    # Queue credential sets for processing by worker threads
-    for credential in fAllCredentials:
-        logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
-        try:
-            # Queue individual credential set for ECS resource discovery
-            # Note: Single parameter queuing - credential dictionary contains all needed info
-            checkqueue.put(credential)
-        except ClientError as my_Error:
-            # Handle authorization failures during credential queuing
-            if "AuthFailure" in str(my_Error):
-                logging.error(
-                    f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
-                )
-                logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
-                pass
-
-    # Wait for all queued work to complete before proceeding
-    checkqueue.join()
-    pbar.close()
+    # Queue credential sets for processing by worker threads with progress tracking
+    with create_progress_bar() as progress:
+        task = progress.add_task("Discovering ECS clusters, services and tasks", total=len(fAllCredentials))
+        for credential in fAllCredentials:
+            logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
+            try:
+                # Queue individual credential set for ECS resource discovery with progress tracking
+                # Tuple format: (credential, progress, task)
+                checkqueue.put((credential, progress, task))
+            except ClientError as my_Error:
+                # Handle authorization failures during credential queuing
+                if "AuthFailure" in str(my_Error):
+                    logging.error(
+                        f"Authorization Failure accessing account {credential['AccountId']} in {credential['Region']} region"
+                    )
+                    logging.warning(f"It's possible that the region {credential['Region']} hasn't been opted-into")
+                    pass
+
+        # Wait for all queued work to complete before proceeding
+        checkqueue.join()
     return AllInstances
 
 
@@ -514,7 +506,7 @@ if __name__ == "__main__":
         print()
         milestone_time1 = time()
         print(
-            f"{Fore.GREEN}\t\tCredential discovery and region enumeration took: {(milestone_time1 - begin_time):.3f} seconds{Fore.RESET}"
+            f"[green]\t\tCredential discovery and region enumeration took: {(milestone_time1 - begin_time):.3f} seconds"
         )
         print()
 
@@ -549,7 +541,7 @@ if __name__ == "__main__":
     # Display performance timing metrics for operational optimization and SLA compliance
     if pTiming:
         print(ERASE_LINE)
-        print(f"{Fore.GREEN}This script took {time() - begin_time:.2f} seconds{Fore.RESET}")
+        print(f"[green]This script took {time() - begin_time:.2f} seconds")
 
     print(ERASE_LINE)