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

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)
 

runbooks/inventory/list_elbs_load_balancers.py

@@ -88,13 +88,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_load_balancers2, get_all_credentials
-from tqdm.auto import tqdm
+from runbooks.common.rich_utils import create_progress_bar
 
-init()
 __version__ = "2024.05.06"
-ERASE_LINE = "\x1b[2K"
 begin_time = time()
 
 
@@ -306,20 +304,24 @@ def find_all_elbs(fAllCredentials: list, ffragment: list, fstatus: str):
         worker.start()
 
     # Queue credential sets with progress tracking for operational visibility
-    for credential in tqdm(fAllCredentials):
-        logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
-        try:
-            # Queue credential set with fragment and status filters for targeted discovery
-            # Tuple format: (credentials, fragment_filter, status_filter)
-            checkqueue.put((credential, ffragment, fstatus))
-        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
+    with create_progress_bar() as progress:
+        task = progress.add_task("Queueing ELB discovery tasks", total=len(fAllCredentials))
+        for credential in fAllCredentials:
+            logging.info(f"Beginning to queue data - starting with {credential['AccountId']}")
+            try:
+                # Queue credential set with fragment and status filters for targeted discovery
+                # Tuple format: (credentials, fragment_filter, status_filter)
+                checkqueue.put((credential, ffragment, fstatus))
+            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
+            finally:
+                progress.update(task, advance=1)
 
     # Wait for all queued work to complete before proceeding
     checkqueue.join()
@@ -396,13 +398,13 @@ 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)
 
     # Display comprehensive operational summary for executive traffic management reporting
     print(
-        f"{Fore.RED}Found {len(All_Load_Balancers)} Load Balancers across {AccountNum} profiles across {RegionNum} regions{Fore.RESET}"
+        f"[red]Found {len(All_Load_Balancers)} Load Balancers across {AccountNum} profiles across {RegionNum} regions"
     )
     print()
 

runbooks/inventory/list_enis_network_interfaces.py

@@ -96,11 +96,10 @@ from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
 
 # from datetime import datetime
-from colorama import Fore, init
+from runbooks.common.rich_utils import console
 from Inventory_Modules import display_results, find_account_enis2, get_all_credentials
-from tqdm.auto import tqdm
+from runbooks.common.rich_utils import create_progress_bar
 
-init()
 
 __version__ = "2024.10.24"
 
@@ -269,8 +268,8 @@ def check_accounts_for_enis(fCredentialList, fip=None, fPublicOnly: bool = False
             """
             while True:
                 # Retrieve ENI discovery work item from thread-safe queue
-                c_account_credentials, c_region, c_fip, c_PlacesToLook, c_PlaceCount = self.queue.get()
-                pbar.update()  # Update progress tracking for operational visibility
+                c_account_credentials, c_region, c_fip, c_PlacesToLook, c_PlaceCount, c_progress, c_task = self.queue.get()
+                c_progress.update(c_task, advance=1)  # Update progress tracking for operational visibility
                 logging.info(f"De-queued info for account {c_account_credentials['AccountId']}")
 
                 try:
@@ -323,13 +322,6 @@ def check_accounts_for_enis(fCredentialList, fip=None, fPublicOnly: bool = False
     # Initialize queue-based threading architecture for scalable ENI discovery
     checkqueue = Queue()
 
-    # Initialize progress tracking for operational visibility during large-scale operations
-    pbar = tqdm(
-        desc=f"Finding enis from {len(CredentialList)} accounts / regions",
-        total=len(fCredentialList),
-        unit=" locations",
-    )
-
     # Initialize results list for aggregating discovered ENIs
     Results = []
     PlaceCount = 0
@@ -347,24 +339,26 @@ def check_accounts_for_enis(fCredentialList, fip=None, fPublicOnly: bool = False
         worker.start()
 
     # Queue credential sets for processing by worker threads
-    for credential in fCredentialList:
-        logging.info(f"Connecting to account {credential['AccountId']} in region {credential['Region']}")
-        try:
-            # Queue credential set with IP filter and progress tracking parameters
-            # Tuple format: (credentials, region, ip_filter, total_places, current_count)
-            checkqueue.put((credential, credential["Region"], fip, PlacesToLook, PlaceCount))
-            PlaceCount += 1
-        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()
+    with create_progress_bar() as progress:
+        task = progress.add_task("Discovering ENIs", total=len(fCredentialList))
+        for credential in fCredentialList:
+            logging.info(f"Connecting to account {credential['AccountId']} in region {credential['Region']}")
+            try:
+                # Queue credential set with IP filter and progress tracking parameters
+                # Tuple format: (credentials, region, ip_filter, total_places, current_count, progress, task)
+                checkqueue.put((credential, credential["Region"], fip, PlacesToLook, PlaceCount, progress, task))
+                PlaceCount += 1
+            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 Results
 
 
@@ -450,7 +444,7 @@ def present_results(f_ENIsFound: list):
 
     # Highlight cost optimization opportunities with unused ENI identification
     print(
-        f"{Fore.RED}Found {len(DetachedENIs)} ENIs that are not listed as 'in-use' and may therefore be costing you additional money while they're unused.{Fore.RESET}"
+        f"[red]Found {len(DetachedENIs)} ENIs that are not listed as 'in-use' and may therefore be costing you additional money while they're unused."
     ) if DetachedENIs else ""
     print()
 
@@ -464,7 +458,6 @@ def present_results(f_ENIsFound: list):
 # Main execution entry point for enterprise ENI discovery and network security analysis
 ##################
 
-ERASE_LINE = "\x1b[2K"
 
 if __name__ == "__main__":
     """
@@ -518,7 +511,7 @@ if __name__ == "__main__":
 
     # Display performance timing metrics for operational optimization and SLA compliance
     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")
 
 # Display completion message for user confirmation and operational closure
 print()

runbooks/inventory/list_guardduty_detectors.py

@@ -95,10 +95,9 @@ import Inventory_Modules
 from account_class import aws_acct_access
 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 get_all_credentials
 
-init()
 __version__ = "2023.07.18"
 
 # Parse enterprise command-line arguments with GuardDuty-specific security management options
@@ -150,7 +149,6 @@ logging.getLogger("urllib3").setLevel(logging.CRITICAL)
 # Initialize enterprise GuardDuty discovery and security management operations
 ##########################
 
-ERASE_LINE = "\x1b[2K"
 
 # Initialize AWS account access for GuardDuty administrative operations
 aws_acct = aws_acct_access(pProfile)
@@ -337,7 +335,7 @@ for credential in AllCredentials:
             # Display progress for accounts without GuardDuty detectors for operational visibility
             print(
                 ERASE_LINE,
-                f"{Fore.RED}No luck in account: {credential['AccountId']} in region {credential['Region']}{Fore.RESET} -- {places_to_try} of {len(AllCredentials)}",
+                f"[red]No luck in account: {credential['AccountId']} in region {credential['Region']} -- {places_to_try} of {len(AllCredentials)}",
                 end="\r",
             )
     except ClientError as my_Error:

runbooks/inventory/list_iam_policies.py

@@ -94,12 +94,10 @@ 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_policies2, find_policy_action2, get_all_credentials
 
-init()
 __version__ = "2023.12.12"
-ERASE_LINE = "\x1b[2K"
 begin_time = time()
 
 
@@ -392,7 +390,7 @@ if __name__ == "__main__":
 
     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(f"These accounts were skipped - as requested: {pSkipAccounts}") if pSkipAccounts is not None else print()
     print()
     print(

runbooks/inventory/list_iam_roles.py

@@ -43,10 +43,9 @@ from time import sleep, time
 import boto3
 from ArgumentsClass import CommonArguments
 from botocore.exceptions import ClientError
-from colorama import Fore, init
 from Inventory_Modules import display_results, find_in, get_all_credentials
+from runbooks.common.rich_utils import console
 
-init()
 __version__ = "2023.11.06"
 
 
@@ -249,8 +248,8 @@ def find_and_collect_roles_across_accounts(fAllCredentials: list, frole_fragment
         print(f"Listing out all roles across {len(fAllCredentials)} accounts")
         print()
     elif pExact:
-        print(
-            f"Looking for a role {Fore.RED}exactly{Fore.RESET} named one of these strings {frole_fragments} across {len(fAllCredentials)} accounts"
+        console.print(
+            f"Looking for a role [red]exactly[/red] named one of these strings {frole_fragments} across {len(fAllCredentials)} accounts"
         )
         print()
     else:
@@ -475,7 +474,6 @@ if __name__ == "__main__":
     logging.getLogger("s3transfer").setLevel(logging.CRITICAL)
     logging.getLogger("urllib3").setLevel(logging.CRITICAL)
 
-    ERASE_LINE = "\x1b[2K"
     time_to_sleep = 5
     begin_time = time()
 
@@ -511,8 +509,8 @@ if __name__ == "__main__":
         )
 
     if pTiming:
-        print(ERASE_LINE)
-        print(f"{Fore.GREEN}This script took {time() - begin_time:.2f} seconds{Fore.RESET}")
+        console.print()
+        console.print(f"[green]This script took {time() - begin_time:.2f} seconds[/green]")
     print()
     print("Thanks for using this script...")
     print()

runbooks/inventory/list_iam_saml_providers.py

@@ -101,14 +101,12 @@ import boto3
 from account_class import aws_acct_access
 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_saml_components_in_acct2, get_child_access3
 
-init()
 __version__ = "2024.03.27"
 
 begin_time = time()
-ERASE_LINE = "\x1b[2K"
 
 
 ##################
@@ -254,7 +252,7 @@ def all_my_saml_providers(faws_acct: aws_acct_access, fChildAccounts: list, f_ac
                     idpNum = len(Idps)
                     logging.info(f"Account: {account['AccountId']} | Region: {pRegion} | Found {idpNum} Idps")
                     logging.info(
-                        f"{ERASE_LINE}{Fore.RED}Account: {account['AccountId']} pRegion: {pRegion} Found {idpNum} Idps.{Fore.RESET}"
+                        f"{ERASE_LINE}[red]Account: {account['AccountId']} pRegion: {pRegion} Found {idpNum} Idps."
                     )
 
                     # Process discovered identity providers and extract metadata
@@ -342,7 +340,7 @@ if __name__ == "__main__":
     RegionsFound = list(set([x["Region"] for x in IdpsFound]))
     print()
     print(
-        f"{Fore.RED}Found {len(IdpsFound)} Idps across {len(AccountsFound)} accounts in {len(RegionsFound)} regions{Fore.RESET}"
+        f"[red]Found {len(IdpsFound)} Idps across {len(AccountsFound)} accounts in {len(RegionsFound)} regions"
     )
     print()
 
@@ -353,7 +351,7 @@ 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()
     print("Thanks for using this script...")
     print()