runbooks 0.7.0__py3-none-any.whl → 0.7.6__py3-none-any.whl

runbooks/inventory/cfn_move_stack_instances.py

@@ -1,1526 +0,0 @@
-#!/usr/bin/env python3
-"""
-Enterprise AWS CloudFormation StackSet Instance Migration Tool
-
-Advanced enterprise-grade automation tool for migrating CloudFormation stack instances between
-StackSets without resource disruption or service interruption. Designed for complex organizational
-restructuring, compliance alignment, and governance optimization across multi-account AWS
-Organizations environments with comprehensive safety controls and recovery mechanisms.
-
-**Enterprise CloudFormation Management**: Sophisticated StackSet migration operations with
-comprehensive drift detection, batch processing optimization, and enterprise-grade error handling.
-
-Core Migration Capabilities:
-    - Zero-downtime stack instance migration between StackSets
-    - Automated template body extraction and cleanup from source StackSets
-    - Parameter preservation and validation during migration operations
-    - IAM capability requirement detection and automatic handling
-    - Batch processing optimization for large-scale migrations (10 instances per operation)
-
-Advanced Safety & Recovery Features:
-    - Comprehensive drift detection and validation before migration
-    - Automatic recovery file generation with stack instance metadata
-    - Transaction-style operations with rollback capabilities
-    - Real-time operation monitoring with detailed progress reporting
-    - Validation checkpoints throughout the migration process
-
-Enterprise Migration Workflow:
-
-    **New StackSet Creation Path:**
-    1. Template body extraction from existing StackSet with JSON cleanup
-    2. Parameter analysis and preservation from source StackSet
-    3. IAM capability requirement detection (CAPABILITIES_NAMED_IAM)
-    4. New StackSet creation with validated template and parameters
-
-    **Existing StackSet Path:**
-    1. StackSet validation and compatibility verification
-    2. Parameter and template alignment confirmation
-
-    **Common Migration Operations:**
-    1. Stack instance discovery and metadata collection
-    2. Recovery file generation with comprehensive backup data
-    3. Batch import operations with optimized account grouping
-    4. Continuous operation monitoring and status validation
-    5. Regional deployment parallelization for performance optimization
-    6. Comprehensive success validation and error handling
-    7. Final migration status reporting and audit documentation
-
-Migration Process Components:
-    - Template body analysis with escaped JSON cleanup and validation
-    - Parameter extraction with type validation and default handling
-    - Stack instance identification with comprehensive metadata collection
-    - IAM capability detection through template analysis and validation
-    - Batch operation coordination with account-based grouping strategies
-    - Operation polling with timeout handling and progress monitoring
-    - Recovery file management with detailed backup and restoration data
-
-Enterprise Integration Features:
-    - Integration with AWS Organizations for account validation
-    - Cross-account IAM role management and validation
-    - CloudFormation drift detection integration for pre-migration validation
-    - Comprehensive audit logging for compliance and governance requirements
-    - Enterprise monitoring system integration for operational visibility
-
-Security & Compliance:
-    - Pre-migration drift detection ensuring infrastructure consistency
-    - IAM permission validation for cross-account operations
-    - Comprehensive audit trail generation for compliance reporting
-    - Recovery mechanism validation ensuring operational continuity
-    - Resource-level validation preventing unintended modifications
-
-Performance Optimizations:
-    - Batch processing with optimal instance grouping (10 per operation)
-    - Regional deployment parallelization reducing migration time
-    - Account aggregation strategies for efficient StackSet operations
-    - Operation polling optimization reducing API call overhead
-    - Memory-efficient processing for large-scale organizational migrations
-
-Error Handling & Recovery:
-    - Transaction-style operations with automatic rollback capabilities
-    - Comprehensive error categorization and recovery guidance
-    - Real-time operation monitoring with detailed failure analysis
-    - Recovery file generation for manual intervention scenarios
-    - Validation checkpoints ensuring migration integrity
-
-Command-Line Interface:
-    - --old: Source StackSet name for migration operations
-    - --new: Target StackSet name or creation specification
-    - --Account: Specific account selection for targeted migrations
-    - --Empty: Empty StackSet creation for template copying
-    - --recovery: Recovery mode operation using backup files
-    - --drift-check: Pre-migration drift detection and validation
-
-Usage Examples:
-    Full migration with drift checking:
-    ```bash
-    python cfn_move_stack_instances.py --old LegacyStackSet --new ModernStackSet --drift-check
-    ```
-
-    Selective account migration:
-    ```bash
-    python cfn_move_stack_instances.py --old OldStack --new NewStack -A 123456789012 234567890123
-    ```
-
-    Recovery operation from backup:
-    ```bash
-    python cfn_move_stack_instances.py --recovery
-    ```
-
-Dependencies:
-    - boto3: AWS SDK for CloudFormation and Organizations operations
-    - account_class: Enterprise AWS account access management
-    - ArgumentsClass: Standardized command-line argument processing
-    - colorama: Cross-platform terminal color support for operational visibility
-
-Version: 2024.02.16 - Enterprise Enhanced Edition
-Author: AWS Cloud Foundations Team
-License: Internal Enterprise Use
-"""
-
-# import pprint
-# import Inventory_Modules
-import logging
-import sys
-from datetime import datetime
-from os import remove
-from os.path import exists, split
-from time import sleep, time
-
-from account_class import aws_acct_access
-from ArgumentsClass import CommonArguments
-from botocore.exceptions import ClientError, WaiterError
-from colorama import Fore, Style, init
-
-init()
-__version__ = "2024.02.16"
-
-
-##################
-# Functions
-##################
-def parse_args(args):
-    """
-    Configure and parse enterprise-grade command-line arguments for StackSet instance migration.
-
-    Establishes comprehensive command-line interface for CloudFormation StackSet migration
-    operations with enterprise-specific parameters including drift detection, recovery modes,
-    account filtering, and operational safety controls. Designed for complex organizational
-    migrations with detailed configuration options and validation requirements.
-
-    Args:
-        args: Command-line arguments list from sys.argv[1:] for argument parsing
-
-    Returns:
-        argparse.Namespace: Parsed command-line arguments containing:
-            - pOldStackSet: Source StackSet name for migration operations
-            - pNewStackSet: Target StackSet name or creation specification
-            - pAccountsToMove: List of specific AWS account numbers for targeted migration
-            - pEmpty: Boolean flag for empty StackSet creation with template copying
-            - pRecoveryFlag: Boolean flag for recovery mode operation using backup files
-            - pDriftCheckFlag: Boolean flag for pre-migration drift detection validation
-            - Standard CommonArguments: Profile, region, confirmation, verbosity, timing
-
-    Command-Line Arguments:
-
-        **Core Migration Parameters:**
-        --old: Source StackSet name containing stack instances to migrate
-            - Required for all migration operations except recovery mode
-            - Validates StackSet existence and access permissions
-            - Used for template body and parameter extraction
-
-        --new: Target StackSet name for migration destination
-            - Can specify existing StackSet or trigger new StackSet creation
-            - Validates compatibility with source StackSet template and parameters
-            - Used for import operations and final migration destination
-
-        **Account Selection & Filtering:**
-        -A, --Account: Specific AWS account numbers for targeted migration
-            - Supports multiple account specification for batch operations
-            - Validates account membership in AWS Organizations
-            - Enables selective migration for phased organizational changes
-
-        **Operational Mode Controls:**
-        --Empty, --empty: Create empty target StackSet with template copying
-            - Copies template body and parameters without stack instances
-            - Useful for template validation and staging environments
-            - Enables pre-validation of StackSet creation before migration
-
-        --recovery: Enable recovery mode operation using backup files
-            - Utilizes previously generated recovery files for rollback operations
-            - Provides transaction-style recovery for failed migrations
-            - Enables manual intervention and recovery scenarios
-
-        --drift-check: Enable comprehensive pre-migration drift detection
-            - Validates infrastructure consistency before migration operations
-            - Prevents migration of drifted stack instances requiring remediation
-            - Provides detailed drift analysis and remediation guidance
-
-        **Standard Enterprise Arguments:**
-        - Single region operation for controlled migration scope
-        - Single profile operation for consistent credential management
-        - Interactive confirmation for safety-critical operations
-        - Configurable verbosity for operational visibility and debugging
-        - Execution timing for performance monitoring and optimization
-        - Version information for operational tracking and audit requirements
-
-    Enterprise Integration Features:
-        - Integration with CommonArguments for standardized enterprise CLI patterns
-        - Comprehensive help documentation for operational guidance
-        - Argument validation and error handling for operational safety
-        - Script name extraction for contextual help and error messaging
-
-    Security & Validation:
-        - Account number validation preventing unauthorized access
-        - StackSet name validation ensuring proper resource identification
-        - Parameter validation preventing configuration errors
-        - Access control validation through AWS credential verification
-
-    Operational Safety Controls:
-        - Interactive confirmation for destructive operations
-        - Recovery mode availability for rollback scenarios
-        - Drift detection integration for infrastructure validation
-        - Comprehensive error handling and user guidance
-    """
-    # Extract script name for contextual argument grouping and help documentation
-    script_path, script_name = split(sys.argv[0])
-
-    # Initialize enterprise argument parser with standard organizational controls
-    parser = CommonArguments()
-    parser.singleregion()  # Controlled regional scope for migration safety
-    parser.singleprofile()  # Consistent credential management across operations
-    parser.confirm()  # Interactive confirmation for safety-critical operations
-    parser.verbosity()  # Configurable logging for operational visibility
-    parser.timing()  # Performance monitoring for enterprise analytics
-    parser.version(__version__)  # Version tracking for operational audit requirements
-
-    # Define script-specific argument group for StackSet migration parameters
-    local = parser.my_parser.add_argument_group(script_name, "Parameters specific to this script")
-
-    # Source StackSet specification for migration operations
-    local.add_argument(
-        "--old",
-        dest="pOldStackSet",
-        metavar="The name of the old stackset",
-        help="This is the name of the old stackset, which manages the existing stack instances in the legacy accounts.",
-    )
-
-    # Target StackSet specification for migration destination
-    local.add_argument(
-        "--new",
-        dest="pNewStackSet",
-        metavar="The name of the new stackset",
-        help="This is the name of the new stackset, which will manage the existing stack instances going forward.",
-    )
-
-    # Account filtering for selective migration operations
-    local.add_argument(
-        "-A",
-        "--Account",
-        dest="pAccountsToMove",
-        default=None,
-        nargs="*",
-        metavar="Account Numbers",
-        help="The account(s) to be moved from one stackset to another",
-    )
-
-    # Empty StackSet creation mode for template copying and validation
-    local.add_argument(
-        "--Empty",
-        "--empty",
-        dest="pEmpty",
-        action="store_true",
-        help="Whether to simply create an empty (but copied) new stackset from the 'old' stackset",
-    )
-
-    # Recovery mode operation for rollback and manual intervention scenarios
-    local.add_argument(
-        "--recovery", dest="pRecoveryFlag", action="store_true", help="Whether we should use the recovery file."
-    )
-
-    # Pre-migration drift detection for infrastructure validation
-    local.add_argument(
-        "--drift-check",
-        dest="pDriftCheckFlag",
-        action="store_true",
-        help="Whether we should check for drift before moving instances",
-    )
-
-    # Parse and validate all command-line arguments
-    return parser.my_parser.parse_args(args)
-
-
-def check_stack_set_drift_status(faws_acct: aws_acct_access, fStack_set_name: str, fOperation_id=None) -> dict:
-    """
-    Execute and monitor CloudFormation StackSet drift detection for pre-migration validation.
-
-    Performs comprehensive drift detection analysis on CloudFormation StackSets to ensure
-    infrastructure consistency before migration operations. Supports both drift detection
-    initiation and operation monitoring with enterprise-grade error handling and parallel
-    processing optimization for large-scale organizational environments.
-
-    Args:
-        faws_acct (aws_acct_access): Authenticated AWS account access object for API operations
-        fStack_set_name (str): CloudFormation StackSet name for drift detection analysis
-        fOperation_id (str, optional): Existing drift detection operation ID for monitoring.
-            None triggers new drift detection initiation.
-
-    Returns:
-        dict: Comprehensive drift detection operation result containing:
-            - OperationId: CloudFormation drift detection operation identifier
-            - Success: Boolean indicating successful operation initiation or completion
-            - ErrorMessage: Detailed error information for troubleshooting (on failure)
-            - Drift detection status and statistics (when monitoring existing operation)
-
-    Drift Detection Operations:
-
-        **New Drift Detection Initiation (fOperation_id=None):**
-        - CloudFormation detect_stack_set_drift API call with optimized preferences
-        - Parallel region processing for performance optimization (RegionConcurrencyType: PARALLEL)
-        - Failure tolerance configuration (10% FailureTolerancePercentage)
-        - Maximum concurrency optimization (100% MaxConcurrentPercentage)
-        - Operation ID capture for subsequent monitoring operations
-
-        **Existing Operation Monitoring (fOperation_id provided):**
-        - Continuous operation status polling using describe_stack_set_operation
-        - Real-time drift detection progress monitoring and reporting
-        - Comprehensive drift analysis including drifted, in-sync, and failed instances
-        - Operation completion detection with detailed status reporting
-
-    Enterprise Drift Detection Features:
-        - Multi-region parallel processing for performance optimization
-        - Configurable failure tolerance for resilient drift detection
-        - Comprehensive error handling for various CloudFormation exceptions
-        - Real-time operation monitoring with detailed progress reporting
-        - Integration with pre-migration validation workflows
-
-    Error Handling & Recovery:
-        - InvalidOperationException: Handles invalid drift detection requests
-        - StackSetNotFoundException: Validates StackSet existence before operations
-        - OperationInProgressException: Detects and manages concurrent drift operations
-        - Automatic operation ID extraction from error messages for recovery
-
-    Drift Detection Status Analysis:
-        - DriftStatus: IN_SYNC, DRIFTED indicating overall StackSet drift state
-        - DriftDetectionStatus: COMPLETED, IN_PROGRESS, FAILED operation status
-        - TotalStackInstancesCount: Complete inventory of StackSet instances
-        - DriftedStackInstancesCount: Number of instances with configuration drift
-        - InSyncStackInstancesCount: Number of instances matching expected configuration
-        - FailedStackInstancesCount: Number of instances with drift detection failures
-
-    Performance Optimizations:
-        - Parallel region processing reducing drift detection time
-        - Optimized failure tolerance balancing speed and reliability
-        - Maximum concurrency configuration for large StackSet environments
-        - Efficient operation polling patterns reducing API call overhead
-
-    Enterprise Integration:
-        - Integration with StackSet migration workflows for pre-migration validation
-        - Comprehensive logging for operational visibility and troubleshooting
-        - Error message preservation for enterprise monitoring and alerting
-        - Operation ID management for long-running drift detection processes
-
-    Security & Compliance:
-        - AWS credential validation through authenticated account access
-        - CloudFormation API permission validation for drift detection operations
-        - Comprehensive audit logging for compliance and governance requirements
-        - Error handling preventing sensitive information exposure
-
-    Usage in Migration Context:
-        - Pre-migration infrastructure consistency validation
-        - Drift remediation requirement identification before StackSet migration
-        - Risk assessment for migration operations on drifted infrastructure
-        - Compliance validation for organizational governance requirements
-    """
-
-    import logging
-
-    # Initialize CloudFormation client for drift detection operations
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    Sync_Has_Started = False
-    time_waited = 0
-
-    if fOperation_id is None:
-        # Initiate new drift detection operation with enterprise-optimized preferences
-        try:
-            # Execute drift detection with parallel processing for performance optimization
-            response = client_cfn.detect_stack_set_drift(
-                StackSetName=fStack_set_name,
-                OperationPreferences={
-                    "RegionConcurrencyType": "PARALLEL",  # Parallel region processing for speed
-                    "FailureTolerancePercentage": 10,  # 10% failure tolerance for resilience
-                    "MaxConcurrentPercentage": 100,  # Maximum concurrency for performance
-                },
-            )
-
-            # Capture operation ID for monitoring and return successful initiation
-            fOperation_id = response["OperationId"]
-            return_response = {"OperationId": fOperation_id, "Success": True}
-
-        except client_cfn.exceptions.InvalidOperationException as myError:
-            # Handle invalid drift detection operation requests
-            logging.error(f"There's been an error: {myError}")
-            return_response = {"ErrorMessage": myError, "Success": False}
-
-        except client_cfn.exceptions.StackSetNotFoundException as myError:
-            # Handle non-existent StackSet validation errors
-            logging.error(f"There's been an error: {myError}")
-            return_response = {"ErrorMessage": myError, "Success": False}
-
-        except client_cfn.exceptions.OperationInProgressException as myError:
-            # Handle concurrent drift detection operations with automatic recovery
-            logging.error(f"There's a drift-detection process already running: {myError}")
-
-            # Extract existing operation ID from error message for monitoring
-            OperationId = myError.response["Error"]["Message"][myError.response["Error"]["Message"].rfind(":") + 2 :]
-            return_response = {"OperationId": OperationId, "Success": True}
-
-        return return_response
-    else:
-        # Monitor existing drift detection operation with comprehensive status analysis
-        """
-		The response we're going to get from this "describe" operation looks like this:
-		{
-		"StackSetOperation": {
-			"OperationId": "4e23045a-xxxx-xxxx-xxxx-bad01ed6902a",
-			"StackSetId": "Test4-IOT6:735b8599-xxxx-xxxx-xxxx-7bc78fe8b817",
-			"Action": "DETECT_DRIFT",
-			"Status": "SUCCEEDED",
-			"OperationPreferences": {
-				"RegionConcurrencyType": "PARALLEL",
-				"RegionOrder": [],
-				"FailureTolerancePercentage": 10,
-				"MaxConcurrentPercentage": 100
-			},
-			"AdministrationRoleARN": "arn:aws:iam::517713657778:role/AWSCloudFormationStackSetAdministrationRole",
-			"ExecutionRoleName": "AWSCloudFormationStackSetExecutionRole",
-			"CreationTimestamp": "2022-09-19T16:55:44.358000+00:00",
-			"EndTimestamp": "2022-09-19T16:59:32.138000+00:00",
-			"StackSetDriftDetectionDetails": {
-				"DriftStatus": "IN_SYNC",
-				"DriftDetectionStatus": "COMPLETED",
-				"LastDriftCheckTimestamp": "2022-09-19T16:59:00.324000+00:00",
-				"TotalStackInstancesCount": 39,
-				"DriftedStackInstancesCount": 0,
-				"InSyncStackInstancesCount": 39,
-				"InProgressStackInstancesCount": 0,
-				"FailedStackInstancesCount": 0
-				}
-			}
-		}
-		"""
-        Finished = False
-        while Finished is False:
-            try:
-                response = client_cfn.describe_stack_set_operation(
-                    StackSetName=fStack_set_name,
-                    OperationId=fOperation_id,
-                )
-                Start_Time = response["StackSetOperation"]["CreationTimestamp"]
-                Operation_Status = response["StackSetOperation"]["Status"]
-                if "StackSetDriftDetectionDetails" in response["StackSetOperation"].keys():
-                    Drift_Detection_Status = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "DriftDetectionStatus"
-                    ]
-                    if (
-                        "LastDriftCheckTimestamp"
-                        in response["StackSetOperation"]["StackSetDriftDetectionDetails"].keys()
-                    ):
-                        Sync_Has_Started = True
-                    else:
-                        Sync_Has_Started = False
-                if Operation_Status == "RUNNING" and Sync_Has_Started:
-                    # TODO: Give a decent status, Wait a little longer, and try again
-                    Last_Instances_Finished = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "LastDriftCheckTimestamp"
-                    ]
-                    Check_Failed = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "FailedStackInstancesCount"
-                    ]
-                    Total_Stack_Instances = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "TotalStackInstancesCount"
-                    ]
-                    Drifted_Instances = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "DriftedStackInstancesCount"
-                    ]
-                    In_Sync_Instances = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "InSyncStackInstancesCount"
-                    ]
-                    Currently_Checking = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "InProgressStackInstancesCount"
-                    ]
-                    Time_Taken = Last_Instances_Finished - Start_Time
-                    Checked_Instances = In_Sync_Instances + Drifted_Instances + Check_Failed
-                    Time_Left = (Time_Taken / Checked_Instances) * Currently_Checking
-                    print(
-                        f"{ERASE_LINE} It's taken {Time_Taken} to detect on {Checked_Instances} "
-                        f"instances, which means we probably have {Time_Left} left to go for {Currently_Checking} more stack instances",
-                        end="\r",
-                    )
-                    logging.info(f"{response}")
-                    return_response = {
-                        "OperationStatus": Operation_Status,
-                        "StartTime": Start_Time,
-                        "EndTime": None,
-                        "DriftedInstances": Drifted_Instances,
-                        "FailedInstances": Check_Failed,
-                        "StackInstancesChecked": Total_Stack_Instances,
-                        "Success": False,
-                    }
-                    Finished = False
-                elif Operation_Status == "RUNNING" and not Sync_Has_Started:
-                    # TODO: Give a decent status, Wait a little longer, and try again
-                    time_waited += sleep_interval
-                    print(
-                        f"{ERASE_LINE} We're still waiting for the Sync to start... Sleeping for {time_waited} seconds",
-                        end="\r",
-                    )
-                    Finished = False
-                elif Operation_Status == "SUCCEEDED":
-                    End_Time = response["StackSetOperation"]["EndTimestamp"]
-                    Total_Stack_Instances = response["StackSetOperation"]["StackSetDriftDetectionDetails"][
-                        "TotalStackInstancesCount"
-                    ]
-                    return_response.update(
-                        {
-                            "OperationStatus": Operation_Status,
-                            "StartTime": Start_Time,
-                            "EndTime": End_Time,
-                            "StackInstancesChecked": Total_Stack_Instances,
-                            "Success": True,
-                        }
-                    )
-                    Finished = True
-            except client_cfn.exceptions.StackSetNotFoundException as myError:
-                logging.error(f"There's been an error: {myError}")
-                return_response = {"ErrorMessage": myError, "Success": False}
-                Finished = True
-            except client_cfn.exceptions.OperationNotFoundException as myError:
-                logging.error(f"There's been an error: {myError}")
-                return_response = {"ErrorMessage": myError, "Success": False}
-                Finished = True
-            logging.info(f"Sleeping for {sleep_interval} seconds")
-            sleep(sleep_interval)
-        return return_response
-
-
-def check_stack_set_status(faws_acct: aws_acct_access, fStack_set_name: str, fOperationId: str = None) -> dict:
-    """
-    response = client.describe_stack_set_operation(
-            StackSetName='string',
-            OperationId='string',
-            CallAs='SELF'|'DELEGATED_ADMIN'
-    )
-    """
-    import logging
-
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    # If the calling process couldn't supply the OpId, then we have to find it, based on the name of the stackset
-    if fOperationId is None:
-        # If there is no OperationId, they've called us after creating the stack-set itself,
-        # so we need to check the status of the stack-set creation, and not the operations that happen to the stackset
-        try:
-            response = client_cfn.describe_stack_set(StackSetName=fStack_set_name, CallAs="SELF")["StackSet"]
-            return_response["StackSetStatus"] = response["Status"]
-            return_response["Success"] = True
-            logging.info(f"Stackset: {fStack_set_name} | Status: {return_response['StackSetStatus']}")
-            return return_response
-        except client_cfn.exceptions.StackSetNotFoundException as myError:
-            logging.error(f"Stack Set {fStack_set_name} Not Found: {myError}")
-            return_response["Success"] = False
-            return return_response
-    try:
-        response = client_cfn.describe_stack_set_operation(
-            StackSetName=fStack_set_name, OperationId=fOperationId, CallAs="SELF"
-        )["StackSetOperation"]
-        return_response["StackSetStatus"] = response["Status"]
-        return_response["Success"] = True
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        print(f"StackSet Not Found: {myError}")
-        return_response["Success"] = False
-    except client_cfn.exceptions.OperationNotFoundException as myError:
-        print(f"Operation Not Found: {myError}")
-        return_response["Success"] = False
-    return return_response
-
-
-def find_if_stack_set_exists(faws_acct: aws_acct_access, fStack_set_name: str) -> dict:
-    """
-    response = client.describe_stack_set(
-            StackSetName='string',
-            CallAs='SELF'|'DELEGATED_ADMIN'
-    )
-    """
-    import logging
-
-    logging.info(f"Verifying whether the stackset {fStack_set_name} in account {faws_acct.acct_number} exists")
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    try:
-        response = client_cfn.describe_stack_set(StackSetName=fStack_set_name, CallAs="SELF")["StackSet"]
-        return_response = {"Payload": response, "Success": True}
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        logging.info(f"StackSet {fStack_set_name} not found in this account.")
-        logging.debug(f"{myError}")
-        return_response["Success"] = False
-    return return_response
-
-
-def get_template_body_and_parameters(faws_acct: aws_acct_access, fExisting_stack_set_name: str) -> dict:
-    """
-    @param faws_acct: object
-    @param fExisting_stack_set_name: The existing stackset name
-    @return: return_response:
-            'stack_set_info' = stack_set_info
-            'Success' = True | False
-
-    describe_stack_set output:
-    {
-            "StackSet": {
-                    "StackSetName": "AWS-Landing-Zone-Baseline-DemoRoles",
-                    "StackSetId": "AWS-Landing-Zone-Baseline-DemoRoles:872bab58-25b9-4785-8973-e7920cbe46d3",
-                    "Status": "ACTIVE",
-                    "TemplateBody":
-                            "AWSTemplateFormatVersion: "2010-09-09"
-                            "Description": Sample of a new role with the use of a managed policy, and a parameterized trust policy.
-                                    Parameters:
-                                            AdministratorAccountId:
-                                                    Type: String
-                                                    Default: "287201118218"
-                                                    Description: AWS Account Id of the administrator account.
-                                                    Resources:
-                                                            SampleRole:
-                                                                    Type: "AWS::IAM::Role"
-                                                                    Properties:
-                                                                            RoleName: DemoRole
-                                                                            Path: /
-                                                                            AssumeRolePolicyDocument:
-                                                                            Version: "2012-10-17"
-                                                                            Statement:
-                                                                                    - Effect: "Allow"
-                                                                                            Principal:
-                                                                                                    AWS:
-                                                                                                            - !Sub 'arn:aws:iam::${AdministratorAccountId}:role/Owner'
-                                                                                                            - !Sub 'arn:aws:iam::${AdministratorAccountId}:user/Paul'
-                                                                                      Action:
-                                                                                            - "sts:AssumeRole"
-                                                                            ManagedPolicyArns:
-                                                                                    - arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess"
-                    "Parameters": [
-                            {
-                                    "ParameterKey": "AdministratorAccountId",
-                                    "ParameterValue": "517713657778",
-                                    "UsePreviousValue": false
-                            }
-                    ],
-                    "Capabilities": [
-                            "CAPABILITY_NAMED_IAM"
-                    ],
-                    "Tags": [
-                            {
-                                    "Key": "AWS_Solutions",
-                                    "Value": "LandingZoneStackSet"
-                            }
-                    ],
-                    "StackSetARN": "arn:aws:cloudformation:us-east-1:517713657778:stackset/AWS-Landing-Zone-Baseline-DemoRoles:872bab58-25b9-4785-8973-e7920cbe46d3",
-                    "AdministrationRoleARN": "arn:aws:iam::517713657778:role/AWSCloudFormationStackSetAdministrationRole",
-                    "ExecutionRoleName": "AWSCloudFormationStackSetExecutionRole",
-                    "StackSetDriftDetectionDetails": {
-                            "DriftStatus": "NOT_CHECKED",
-                            "TotalStackInstancesCount": 0,
-                            "DriftedStackInstancesCount": 0,
-                            "InSyncStackInstancesCount": 0,
-                            "InProgressStackInstancesCount": 0,
-                            "FailedStackInstancesCount": 0
-                    },
-                    "OrganizationalUnitIds": []
-            }
-    }
-    """
-    import logging
-
-    logging.info(f"Connecting to account {faws_acct.acct_number} to get info about stackset {fExisting_stack_set_name}")
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = {"Success": False}
-    try:
-        stack_set_info = client_cfn.describe_stack_set(StackSetName=fExisting_stack_set_name)["StackSet"]
-        return_response["stack_set_info"] = stack_set_info
-        return_response["Success"] = True
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        ErrorMessage = f"{fExisting_stack_set_name} doesn't seem to exist. Please check the spelling"
-        print(f"{ErrorMessage}: {myError}")
-        return_response["Success"] = False
-    return return_response
-
-
-def compare_stacksets(faws_acct: aws_acct_access, fExisting_stack_set_name: str, fNew_stack_set_name: str) -> dict:
-    """
-    The idea here is to compare the templates and parameters of the stacksets, to ensure that the import will succeed.
-    """
-
-    return_response = {
-        "Success": False,
-        "TemplateComparison": False,
-        "CapabilitiesComparison": False,
-        "ParametersComparison": False,
-        "TagsComparison": False,
-        "DescriptionComparison": False,
-        "ExecutionRoleComparison": False,
-    }
-    Stack_Set_Info_old = get_template_body_and_parameters(faws_acct, fExisting_stack_set_name)
-    Stack_Set_Info_new = get_template_body_and_parameters(faws_acct, fNew_stack_set_name)
-    # Time to compare - only the Template Body, Parameters, and Capabilities are critical to making sure the stackset works.
-    return_response["TemplateComparison"] = (
-        Stack_Set_Info_old["stack_set_info"]["TemplateBody"] == Stack_Set_Info_new["stack_set_info"]["TemplateBody"]
-    )
-    return_response["CapabilitiesComparison"] = (
-        Stack_Set_Info_old["stack_set_info"]["Capabilities"] == Stack_Set_Info_new["stack_set_info"]["Capabilities"]
-    )
-    return_response["ParametersComparison"] = (
-        Stack_Set_Info_old["stack_set_info"]["Parameters"] == Stack_Set_Info_new["stack_set_info"]["Parameters"]
-    )
-    return_response["TagsComparison"] = (
-        Stack_Set_Info_old["stack_set_info"]["Tags"] == Stack_Set_Info_new["stack_set_info"]["Tags"]
-    )
-    try:
-        return_response["DescriptionComparison"] = (
-            Stack_Set_Info_old["stack_set_info"]["Description"] == Stack_Set_Info_new["stack_set_info"]["Description"]
-        )
-    except KeyError as myError:
-        # This checks for the presence of the Description key before using it as a key for checking, to resolve an error when it's not there.
-        if (
-            "Description" in Stack_Set_Info_new["stack_set_info"].keys()
-            and Stack_Set_Info_new["stack_set_info"]["Description"] == Default_Description_Text
-        ):
-            print(
-                f"There was no description in the old StackSet, and creating a new one in this way requires one, so we've populated it with a default Description -- '{Default_Description_Text}'\n"
-                f"This won't cause a problem with the migration, just something to note..."
-            )
-            return_response["DescriptionComparison"] = True
-        else:
-            logging.error(f"Description key isn't available... continuing anyway...")
-            return_response["DescriptionComparison"] = True
-    return_response["ExecutionRoleComparison"] = (
-        Stack_Set_Info_old["stack_set_info"]["ExecutionRoleName"]
-        == Stack_Set_Info_new["stack_set_info"]["ExecutionRoleName"]
-    )
-
-    if (
-        return_response["TemplateComparison"]
-        and return_response["CapabilitiesComparison"]
-        and return_response["ParametersComparison"]
-    ):
-        return_response["Success"] = True
-    return return_response
-
-
-def get_stack_ids_from_existing_stack_set(
-    faws_acct: aws_acct_access, fExisting_stack_set_name: str, fAccountsToMove: list = None
-) -> dict:
-    """
-    response = client.list_stack_instances(
-            StackSetName='string',
-            NextToken='string',
-            MaxResults=123,
-            Filters=[
-                    {
-                            'Name': 'DETAILED_STATUS',
-                            'Values': 'string'
-                    },
-            ],
-            StackInstanceAccount='string',
-            StackInstanceRegion='string',
-            CallAs='SELF'|'DELEGATED_ADMIN'
-    )
-    """
-    import logging
-
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    try:
-        response = client_cfn.list_stack_instances(StackSetName=fExisting_stack_set_name, CallAs="SELF")
-        return_response["Stack_instances"] = response["Summaries"]
-        while "NextToken" in response.keys():
-            response = client_cfn.list_stack_instances(
-                StackSetName=fExisting_stack_set_name, CallAs="SELF", NextToken=response["NextToken"]
-            )
-            return_response["Stack_instances"].extend(response["Summaries"])
-        return_response["Success"] = True
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        print(myError)
-        return_response["Success"] = False
-    if fAccountsToMove is None:
-        logging.debug(f"No Account was specified, so all stack-instance-ids are being returned")
-        pass
-    else:
-        # TODO: Replace this below with a "filter(lambda)" syntax
-        return_response["Stack_instances"] = [
-            stacksetinfo
-            for stacksetinfo in return_response["Stack_instances"]
-            if stacksetinfo["Account"] in fAccountsToMove
-        ]
-        logging.debug(
-            f"Account {fAccountsToMove} was specified, so only the {len(return_response['Stack_instances'])} "
-            f"stack-instance-ids matching th{'ose accounts' if len(fAccountsToMove) == 1 else 'at account'} are being returned"
-        )
-    return return_response
-
-
-def write_info_to_file(faws_acct: aws_acct_access, fstack_ids) -> dict:
-    """
-    Docs go here
-    """
-    import logging
-
-    import simplejson as json
-
-    # Create a dictionary that will represent everything we're trying to do
-    try:
-        StackSetsInfo = {
-            "ProfileUsed": pProfile,
-            "ManagementAccount": faws_acct.MgmtAccount,
-            "Region": pRegion,
-            "AccountNumber": faws_acct.acct_number,
-            "AccountsToMove": pAccountsToMove,
-            "OldStackSetName": pOldStackSet,
-            "NewStackSetName": pNewStackSet,
-            "stack_ids": fstack_ids,
-        }
-        logging.info(f"Writing data to the file {InfoFilename}")
-        logging.debug(f"Here's the data we're writing: {StackSetsInfo}")
-        file_data = json.dumps(StackSetsInfo, sort_keys=True, indent=4 * " ", default=str)
-        with open(InfoFilename, "w") as out:
-            print(file_data, file=out)
-        return_response = {"Success": True}
-        return return_response
-    except Exception as myError:
-        error_message = "There was a problem. Not sure... "
-        logging.error(error_message)
-        return_response = {"Success": False, "ErrorMessage": myError}
-        return return_response
-
-
-def read_stack_info_from_file() -> dict:
-    """
-    Docs go here
-    """
-    import logging
-
-    import simplejson as json
-
-    try:
-        with open(InfoFilename) as input_file:
-            my_input_file = json.load(input_file)
-        return_response = {"Success": True, "Payload": my_input_file}
-        return return_response
-    except Exception as myError:
-        error_message = "There was a problem. Not sure... "
-        logging.error(error_message)
-        return_response = {"Success": False, "ErrorMessage": myError}
-        return return_response
-
-
-def create_stack_set_with_body_and_parameters(
-    faws_acct: aws_acct_access, fNew_stack_set_name: str, fStack_set_info: dict
-) -> dict:
-    """
-    response = client.create_stack_set(
-            StackSetName='string',
-            Description='string',
-            TemplateBody='string',
-            TemplateURL='string',
-            StackId='string',
-            Parameters=[
-                    {
-                            'ParameterKey': 'string',
-                            'ParameterValue': 'string',
-                            'UsePreviousValue': True|False,
-                            'ResolvedValue': 'string'
-                    },
-            ],
-            Capabilities=[
-                    'CAPABILITY_IAM'|'CAPABILITY_NAMED_IAM'|'CAPABILITY_AUTO_EXPAND',
-            ],
-            Tags=[
-                    {
-                            'Key': 'string',
-                            'Value': 'string'
-                    },
-            ],
-            AdministrationRoleARN='string',
-            ExecutionRoleName='string',
-            PermissionModel='SERVICE_MANAGED'|'SELF_MANAGED',
-            AutoDeployment={
-                    'Enabled': True|False,
-                    'RetainStacksOnAccountRemoval': True|False
-            },
-            CallAs='SELF'|'DELEGATED_ADMIN',
-            ClientRequestToken='string'
-    )
-    """
-    import logging
-
-    logging.info(
-        f"Creating a new stackset name {fNew_stack_set_name} in account {faws_acct.acct_number} with a template body, parameters, capabilities and tagging from this:"
-    )
-    logging.info(f"{fStack_set_info}")
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    # TODO: We should consider changing the template body to a template url to accommodate really big templates,
-    #  That would mean we need to have an S3 bucket to put the template, which we don't necessarily have at this point, so it's a bigger deal than you might immediately think.
-    #  However, this script doesn't check the size of the template ahead of time, so what happens if we try to create a new stackset template when the old one is too big?
-
-    # TODO: This only creates a new stackset as a "Self-Managed" stackset.
-    #  We need to catch the scenario, when the old stackset was "Service-Managed" and decide whether we create the new one that way (which may be difficult, with automatic deployments, etc),
-    #  Or tell the user that we cannot create a new service-managed stackset, and do they want to create it as a self-managed instead?
-    try:
-        response = client_cfn.create_stack_set(
-            StackSetName=fNew_stack_set_name,
-            TemplateBody=fStack_set_info["TemplateBody"],
-            Description=fStack_set_info["Description"]
-            if "Description" in fStack_set_info.keys()
-            else Default_Description_Text,
-            Parameters=fStack_set_info["Parameters"],
-            Capabilities=fStack_set_info["Capabilities"],
-            Tags=fStack_set_info["Tags"],
-        )
-        return_response["StackSetId"] = response["StackSetId"]
-        return_response["Success"] = True
-    # There is currently no waiter to use for this operation...
-    except (
-        client_cfn.exceptions.NameAlreadyExistsException,
-        client_cfn.exceptions.CreatedButModifiedException,
-        client_cfn.exceptions.LimitExceededException,
-    ) as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-        return_response["Error_Message"] = myError.response["Error"]["Message"]
-    return return_response
-
-
-def disconnect_stack_instances(faws_acct: aws_acct_access, fStack_instances: dict, fOldStackSet: str) -> dict:
-    """
-    response = client.delete_stack_instances(
-            StackSetName='string',
-            Accounts=[
-                    'string',
-            ],
-            DeploymentTargets={
-                    'Accounts': [
-                            'string',
-                    ],
-                    'AccountsUrl': 'string',
-                    'OrganizationalUnitIds': [
-                            'string',
-                    ]
-            },
-            Regions=[
-                    'string',
-            ],
-            OperationPreferences={
-                    'RegionConcurrencyType': 'SEQUENTIAL'|'PARALLEL',
-                    'RegionOrder': [
-                            'string',
-                    ],
-                    'FailureToleranceCount': 123,
-                    'FailureTolerancePercentage': 123,
-                    'MaxConcurrentCount': 123,
-                    'MaxConcurrentPercentage': 123
-            },
-            RetainStacks=True|False,
-            OperationId='string',
-            CallAs='SELF'|'DELEGATED_ADMIN'
-    )
-
-    """
-    import logging
-
-    logging.info(f"Disassociating stacks from {fOldStackSet}")
-    return_response = dict()
-    if len(fStack_instances["Stack_instances"]) == 0:
-        return_response = {
-            "Success": False,
-            "ErrorMessage": f"Stackset {fOldStackSet} has no matching instances",
-            "OperationId": None,
-        }
-        return return_response
-    client_cfn = faws_acct.session.client("cloudformation")
-    regions = set()
-    accounts = set()
-    for item in fStack_instances["Stack_instances"]:
-        regions.add(item["Region"])
-        accounts.add(item["Account"])
-    try:
-        response = client_cfn.delete_stack_instances(
-            StackSetName=fOldStackSet,
-            Accounts=list(accounts),
-            Regions=list(regions),
-            OperationPreferences={
-                "RegionConcurrencyType": "PARALLEL",
-                "FailureTolerancePercentage": 10,
-                "MaxConcurrentPercentage": 100,
-            },
-            RetainStacks=True,
-            CallAs="SELF",
-        )
-        return_response["OperationId"] = response["OperationId"]
-        return_response["Success"] = True
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-    except client_cfn.exceptions.OperationInProgressException as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-    except client_cfn.exceptions.OperationIdAlreadyExistsException as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-    except client_cfn.exceptions.StaleRequestException as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-    except client_cfn.exceptions.InvalidOperationException as myError:
-        logging.error(f"Operation Failed: {myError}")
-        return_response["Success"] = False
-    stack_instance_operation_waiter = client_cfn.get_waiter("stack_delete_complete")
-    try:
-        stack_instance_operation_waiter.wait(StackName=fOldStackSet)
-        return_response["Success"] = True
-    except WaiterError as myError:
-        if "Max attempts exceeded" in myError:
-            logging.error(f"Import didn't complete within 600 seconds")
-        logging.error(myError)
-        return_response["Success"] = False
-    return return_response
-
-
-def create_change_set_for_new_stack():
-    """
-    Do we need to do this?
-    """
-
-
-def populate_new_stack_with_existing_stack_instances(
-    faws_acct: aws_acct_access, fStack_instance_info: list, fNew_stack_name: str
-) -> dict:
-    """
-    response = client.import_stacks_to_stack_set(
-            StackSetName='string',
-            StackIds=[
-                    'string',
-            ],
-            OperationPreferences={
-                    'RegionConcurrencyType': 'SEQUENTIAL'|'PARALLEL',
-                    'RegionOrder': [
-                            'string',
-                    ],
-                    'FailureToleranceCount': 123,
-                    'FailureTolerancePercentage': 123,
-                    'MaxConcurrentCount': 123,
-                    'MaxConcurrentPercentage': 123
-            },
-            OperationId='string',
-            CallAs='SELF'|'DELEGATED_ADMIN'
-    )
-
-    The Operation Id as the response is really important, because that's how we determine whether teh operation is done (or a success),
-    so that we can add 10 more stacks... This can take a long time for a lot of instances...
-    """
-    import logging
-
-    stack_instance_ids = [
-        stack_instance["StackId"]
-        for stack_instance in fStack_instance_info
-        if stack_instance["Status"] in ["CURRENT", "OUTDATED", "CREATE_COMPLETE", "UPDATE_COMPLETE"]
-    ]
-    logging.info(
-        f"Populating new stackset {fNew_stack_name} in account {faws_acct.acct_number} with stack_ids: {stack_instance_ids}"
-    )
-    client_cfn = faws_acct.session.client("cloudformation")
-    return_response = dict()
-    try:
-        response = client_cfn.import_stacks_to_stack_set(
-            StackSetName=fNew_stack_name,
-            StackIds=stack_instance_ids,
-            OperationPreferences={
-                "RegionConcurrencyType": "PARALLEL",
-                "FailureTolerancePercentage": 0,
-                "MaxConcurrentPercentage": 100,
-            },
-            CallAs="SELF",
-        )
-        return_response["OperationId"] = response["OperationId"]
-        return_response["Success"] = True
-    except client_cfn.exceptions.LimitExceededException as myError:
-        logging.error(f"Limit Exceeded: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except client_cfn.exceptions.StackSetNotFoundException as myError:
-        logging.error(f"Stack Set Not Found: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except client_cfn.exceptions.InvalidOperationException as myError:
-        logging.error(f"Invalid Operation: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except client_cfn.exceptions.OperationInProgressException as myError:
-        logging.error(f"Operation is already in progress: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except client_cfn.exceptions.StackNotFoundException as myError:
-        logging.error(f"Stack Not Found: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except client_cfn.exceptions.StaleRequestException as myError:
-        logging.error(f"Stale Request: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    except ClientError as myError:
-        logging.error(f"Client Error: {myError}")
-        return_response["Success"] = False
-        return_response["ErrorMessage"] = myError
-    return return_response
-
-
-##################
-# Main
-##################
-if __name__ == "__main__":
-    args = parse_args(sys.argv[1:])
-    pProfile = args.Profile
-    pRegion = args.Region
-    pForce = args.Confirm
-    pTiming = args.Time
-    verbose = args.loglevel
-    pRecoveryFlag = args.pRecoveryFlag
-    pDriftCheck = args.pDriftCheckFlag
-    # version = args.Version
-    pOldStackSet = args.pOldStackSet
-    pNewStackSet = args.pNewStackSet
-    pAccountsToMove = args.pAccountsToMove
-    pEmpty = args.pEmpty
-    # Logging Settings
-    # Set Log Level
-    logging.basicConfig(level=verbose, format="[%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s")
-    logging.getLogger("boto3").setLevel(logging.CRITICAL)
-    logging.getLogger("botocore").setLevel(logging.CRITICAL)
-    logging.getLogger("s3transfer").setLevel(logging.CRITICAL)
-    logging.getLogger("urllib3").setLevel(logging.CRITICAL)
-
-    ERASE_LINE = "\x1b[2K"
-    # The time between checks to see if the stackset instances have been created, or imported...
-    sleep_interval = 5
-    begin_time = time()
-    Default_Description_Text = "This is a default description"
-    # Currently, this is a hard-stop at 10, but I made it a variable in case they up the limit
-    StackInstancesImportedAtOnce = 10
-    stack_ids = dict()
-
-    aws_acct = aws_acct_access(pProfile)
-    datetime_extension = datetime.now().strftime("%Y%m%d-%H%M")
-    InfoFilename = f"{pOldStackSet}-{pNewStackSet}-{aws_acct.acct_number}-{pRegion}.{datetime_extension}"
-    Use_recovery_file = False
-
-    if pDriftCheck:
-        drift_check_response = check_stack_set_drift_status(aws_acct, pOldStackSet)
-        print(drift_check_response)
-        print(f"Kicked off Drift Sync... now we'll wait {sleep_interval} seconds before checking on the process...")
-        sleep(sleep_interval)
-        if drift_check_response["Success"]:
-            drift_check_response2 = check_stack_set_drift_status(
-                aws_acct, pOldStackSet, drift_check_response["OperationId"]
-            )
-            Total_Stacksets = drift_check_response2["StackInstancesChecked"]
-            Drifted_Stacksets = (
-                drift_check_response2["DriftedInstances"]
-                if "DriftedInstances" in drift_check_response2.keys()
-                else None
-            )
-            Failed_Stacksets = drift_check_response2["FailedInstances"]
-            Duration = drift_check_response2["EndTime"] - drift_check_response2["StartTime"]
-            print()
-            print(
-                f"We're done checking the drift status of the old StackSet\n"
-                f"We found {Total_Stacksets} Total Stacksets\n"
-                f"{Drifted_Stacksets} have drifted, while\n"
-                f"{Failed_Stacksets} failed to be checked\n"
-                f"This process took {Duration} seconds to run"
-            )
-            logging.info(drift_check_response2)
-            print()
-        sys.exit("Exiting...")
-
-    if exists(InfoFilename) and pRecoveryFlag:
-        print(
-            f"You requested to use the recovery file {InfoFilename}, so we'll use that to pick up from where we left off"
-        )
-        Use_recovery_file = True
-    elif pRecoveryFlag:
-        print(
-            f"You requested to use the Recovery file, but we couldn't find one named {InfoFilename}, so we're exiting\n"
-            f"Please supply the proper StackSet, Region and Profile parameters so we can find the recovery file.",
-            file=sys.stderr,
-        )
-        sys.exit(5)
-    elif exists(InfoFilename):
-        print(f"There exists a recovery file for the parameters you've supplied, named {InfoFilename}\n")
-        Use_recovery_file = input(f"Do you want to use this file? (y/n): ") in ["y", "Y"]
-        if not Use_recovery_file:
-            print(
-                f"If you don't want to use that file, please change the filename, and re-run this script, to avoid over-writing it.",
-                file=sys.stderr,
-            )
-            sys.exit(6)
-
-    if Use_recovery_file:
-        fileinput = read_stack_info_from_file()
-        AccountNumber = fileinput["Payload"]["AccountNumber"]
-        if not AccountNumber == aws_acct.acct_number:
-            print(
-                f"You're running this script referencing a different account than the one used last when the recovery file {InfoFilename} was created.\n"
-                f"Please make sure you finish that last task before starting a new one.\n",
-                file=sys.stderr,
-            )
-            sys.exit(4)
-        pAccountsToMove = fileinput["Payload"]["AccountsToMove"]
-        pOldStackSet = fileinput["Payload"]["OldStackSetName"]
-        pNewStackSet = fileinput["Payload"]["NewStackSetName"]
-        pRegion = fileinput["Payload"]["Region"]
-        stack_ids = fileinput["Payload"]["stack_ids"]
-
-    # The following is just letting the user know what we're going to do in this script.
-    # Since this script is by nature intrusive, we want the user to confirm everything before they continue.
-    if pAccountsToMove is None:
-        logging.info(
-            f"Successfully connected to account {aws_acct.acct_number} to move stack instances "
-            f"from {pOldStackSet} to {pNewStackSet}"
-        )
-    else:
-        logging.info(
-            f"Connecting to account {aws_acct.acct_number} to move instances for accounts {pAccountsToMove}"
-            f" from {pOldStackSet} to {pNewStackSet}"
-        )
-    # Check to see if the new StackSet already exists, or we need to create it.
-    if find_if_stack_set_exists(aws_acct, pNewStackSet)["Success"]:
-        print(
-            f"{Fore.GREEN}The 'New' Stackset {pNewStackSet} exists within the account {aws_acct.acct_number}{Fore.RESET}"
-        )
-        NewStackSetExists = True
-    else:
-        print(
-            f"{Fore.RED}The 'New' Stackset {pNewStackSet} does not exist within the account {aws_acct.acct_number}{Fore.RESET}"
-        )
-        NewStackSetExists = False
-    # Check to see if the old StackSet exists, as they may have typed something wrong - or the recovery file was never deleted.
-    if find_if_stack_set_exists(aws_acct, pOldStackSet)["Success"]:
-        print(
-            f"{Fore.GREEN}The 'Old' Stackset {pOldStackSet} exists within the account {aws_acct.acct_number}{Fore.RESET}"
-        )
-        OldStackSetExists = True
-    else:
-        print(
-            f"{Fore.RED}The 'Old' Stackset {pOldStackSet} does not exist within the account {aws_acct.acct_number}{Fore.RESET}"
-        )
-        OldStackSetExists = False
-
-    CompareTemplates = {"Success": False}
-    if OldStackSetExists and NewStackSetExists:
-        CompareTemplates = compare_stacksets(aws_acct, pOldStackSet, pNewStackSet)
-    if OldStackSetExists and not NewStackSetExists:
-        print()
-        print(
-            f"It looks like the new stack-set doesn't yet have a template assigned to it.\n"
-            f"We can simply copy over the template from the source stackset and copy to the new stackset.\n"
-            f"Please answer Y to the prompt below, if you're ok with that."
-        )
-        print()
-    elif not CompareTemplates["Success"]:
-        print()
-        print(
-            f"{Fore.RED}Ok - there's a problem here. The templates or parameters or capabilities in the two stacksets you provided don't match{Fore.RESET}\n"
-            f"It might be a very bad idea to try to import these stacksets, if the templates or other critical components don't match.\n"
-            f"I'd suggest strongly that you answer 'N' to the next prompt... "
-        )
-        print()
-    elif CompareTemplates["Success"] and not (
-        CompareTemplates["TagsComparison"]
-        and CompareTemplates["DescriptionComparison"]
-        and CompareTemplates["ExecutionRoleComparison"]
-    ):
-        print()
-        print(
-            f"{Fore.CYAN}Ok - there {Style.BRIGHT}might{Style.NORMAL} be a problem here. While the templates, parameters and capabilities in the two stacksets you provided match\n"
-            f"Either the Description, the Tags, or the ExecutionRole is different between the two stacksets.\n"
-            f"I'd suggest that you answer 'N' to the next prompt, and then investigate the differences\n"
-            f"No changes were made yet - so you can always run this script again.{Fore.RESET}"
-        )
-        print()
-
-    # Ignore whether or not the recovery file exists, since if it does - it's just updating the variables needed for this run.
-    # We shouldn't be doing much of anything differently, based on whether the recovery file exists.
-    if OldStackSetExists and pEmpty:
-        print(
-            f"You've asked to create an empty stackset called {pNewStackSet} from the existing stackset {pOldStackSet}"
-        )
-        print(
-            f"You specified accounts to move, but we're not doing that, since you asked for this stackset to be created empty."
-        ) if pAccountsToMove is not None else ""
-        """ Create new stackset from old stackset """
-        Stack_Set_Info = get_template_body_and_parameters(aws_acct, pOldStackSet)
-        # Creates the new stack
-        NewStackSetId = create_stack_set_with_body_and_parameters(
-            aws_acct, pNewStackSet, Stack_Set_Info["stack_set_info"]
-        )
-        logging.warning(f"Waiting for new stackset {pNewStackSet} to be created")
-        sleep(sleep_interval)
-        # Checks on the new stack creation
-        NewStackSetStatus = check_stack_set_status(aws_acct, pNewStackSet)
-        intervals_waited = 1
-        # If the creation effort (async) and the creation checking both succeeded...
-        if NewStackSetStatus["Success"] and NewStackSetId["Success"]:
-            # TODO: Fix message about length of time waiting...
-            while NewStackSetStatus["Success"] and not NewStackSetStatus["StackSetStatus"] in ["ACTIVE"]:
-                print(f"Waiting for StackSet {pNewStackSet} to be ready." * intervals_waited, end="\r")
-                sleep(sleep_interval)
-                intervals_waited += 1
-                NewStackSetStatus = check_stack_set_status(aws_acct, pNewStackSet)
-            print(f"{ERASE_LINE}Stackset {pNewStackSet} has been successfully created")
-            # TODO: Use the NewStackSetId Operation Id, to check if the empty new stackset has successfully been created
-            pass
-        # If only the creation effort (async) succeeded, but checking on that operation showed a failure...
-        elif NewStackSetStatus["Success"]:
-            print(
-                f"{Fore.RED}{pNewStackSet} appears to already exist. New stack set failed to be created. Exiting...{Fore.RESET}"
-            )
-            Failure_GoToEnd = True
-            sys.exit(98)
-        # Any other failure scenario
-        else:
-            print(f"{pNewStackSet} failed to be created. Exiting...")
-            Failure_GoToEnd = True
-            sys.exit(99)
-
-    elif OldStackSetExists and not pEmpty:
-        print()
-        if not pForce:  # Checking to see if they've specified no confirmations
-            User_Confirmation = input(f"Do you want to proceed with the migration? (y/n): ") in ["y", "Y"]
-        else:
-            User_Confirmation = True
-        if not User_Confirmation:
-            print(f"User cancelled script", file=sys.stderr)
-            Failure_GoToEnd = True
-            sys.exit(10)
-        # We would only get to this point if (for some reason) the script dies before a new stackset could be made.
-        # In that case, we may not have even written a recovery file yet.
-        if not NewStackSetExists:  # We need to create the new stacksets
-            """
-			1. Determine the template body of the existing stackset.
-			2. Determine the parameters from the existing stackset
-				2.5 Determine whether you need to specify "--capabilities CAPABILITIES_NAMED_IAM" when creating the new stackset 
-			3. Create a new stackset with the template body of the existing stackset.
-			"""
-            print()
-            print(
-                f"You've asked for us to move stacksets from the existing stackset {pOldStackSet}"
-                f" and create a new stackset called: {pNewStackSet}\n"
-                f"Please note that we can only move {StackInstancesImportedAtOnce} stack instances at a time, so we may to loop a few times to do this."
-            )
-            if pAccountsToMove is not None:
-                print(f"But only for account {pAccountsToMove}")
-            print()
-            Stack_Set_Info = get_template_body_and_parameters(aws_acct, pOldStackSet)
-            NewStackSetId = create_stack_set_with_body_and_parameters(
-                aws_acct, pNewStackSet, Stack_Set_Info["stack_set_info"]
-            )
-            logging.warning(f"Waiting for new stackset {pNewStackSet} to be created")
-            sleep(sleep_interval)
-            NewStackSetStatus = check_stack_set_status(aws_acct, pNewStackSet)
-            intervals_waited = 1
-            if NewStackSetStatus["Success"]:
-                while NewStackSetStatus["Success"] and not NewStackSetStatus["StackSetStatus"] in ["ACTIVE"]:
-                    print(f"Waiting for StackSet {pNewStackSet} to be ready", f"." * intervals_waited, end="\r")
-                    sleep(sleep_interval)
-                    intervals_waited += 1
-                    NewStackSetStatus = check_stack_set_status(aws_acct, pNewStackSet)
-                print(f"{ERASE_LINE}Stackset {pNewStackSet} has been successfully created")
-                # TODO: Use the NewStackSetId Operation Id, to check if the empty new stackset has successfully been created
-                pass
-            else:
-                print(f"{pNewStackSet} failed to be created. Exiting...")
-                Failure_GoToEnd = True
-                sys.exit(99)
-
-        else:  # PNewStackSet *does* exist
-            # First time this script has run...
-            print("New Stack Set already exists...")
-
-        """ ######## This code is common across both use-cases ################## """
-        logging.debug(f"Getting Stack Ids from existing stack set {pOldStackSet}")
-        # **** 1. Get the stack-ids from the old stack-set ****
-        if Use_recovery_file:
-            pass
-        else:
-            """
-			1. Get the stack-ids from the old stack-set - write them to a file (in case we need to recover the process)
-			"""
-            stack_ids = get_stack_ids_from_existing_stack_set(aws_acct, pOldStackSet, pAccountsToMove)
-        logging.debug(f"Found {len(stack_ids)} stack ids from stackset {pOldStackSet}")
-        # Write the stack_ids info to a file, so we don't lose this info if the script fails
-        fileresult = write_info_to_file(aws_acct, stack_ids)
-        if not fileresult["Success"]:
-            print(f"Something went wrong.\nError Message: {fileresult['ErrorMessage']}")
-            Failure_GoToEnd = True
-            sys.exit(9)
-        # For every 10 stack-ids, use the OpId below to verify that the Operation has finished:
-        # **** 2. Remove the stack-instances from the old stack-set ****
-        logging.debug(f"Removing stack instances from stackset {pOldStackSet}")
-        DisconnectStackInstances = disconnect_stack_instances(aws_acct, stack_ids, pOldStackSet)
-        if not DisconnectStackInstances["Success"]:
-            if DisconnectStackInstances["ErrorMessage"].find("has no matching instances") > 0 and Use_recovery_file:
-                pass  # This could be because the Old Stackset already had the instances disconnected when the script failed
-            else:
-                print(f"Failure... exiting due to: {DisconnectStackInstances['ErrorMessage']}")
-                Failure_GoToEnd = True
-                sys.exit(7)
-        logging.debug(f"Removed stack instances from {pOldStackSet}")
-        if DisconnectStackInstances["OperationId"] is not None:
-            StackInstancesAreGone = check_stack_set_status(
-                aws_acct, pOldStackSet, DisconnectStackInstances["OperationId"]
-            )
-            if not StackInstancesAreGone["Success"]:
-                Failure_GoToEnd = True
-                sys.exit(
-                    f"There was a problem with removing the stack instances from stackset {pOldStackSet}. Exiting..."
-                )
-            logging.debug(
-                f"The operation id {DisconnectStackInstances['OperationId']} is {StackInstancesAreGone['StackSetStatus']}"
-            )
-            intervals_waited = 1
-            while StackInstancesAreGone["StackSetStatus"] in ["RUNNING"]:
-                print(
-                    f"Waiting for stack instances to be disconnected from stackset {pOldStackSet} -",
-                    # f"." * intervals_waited,
-                    f"{sleep_interval * intervals_waited} seconds waited so far",
-                    end="\r",
-                )
-                sleep(sleep_interval)
-                intervals_waited += 1
-                StackInstancesAreGone = check_stack_set_status(
-                    aws_acct, pOldStackSet, DisconnectStackInstances["OperationId"]
-                )
-            if not StackInstancesAreGone["Success"]:
-                print(f"There was a problem with removing the stack instances from stackset {pOldStackSet}. Exiting...")
-                Failure_GoToEnd = True
-                sys.exit(8)
-        # For every 10 stack-ids:
-        # **** 3. Import those stack-ids into the new stack-set, 10 at a time ****
-        x = 0
-        limit = StackInstancesImportedAtOnce
-        intervals_waited = 1
-        while x < len(stack_ids["Stack_instances"]):
-            stack_ids_subset = [
-                stack_ids["Stack_instances"][x + i] for i in range(limit) if x + i < len(stack_ids["Stack_instances"])
-            ]
-            x += limit
-            print(
-                f"{ERASE_LINE}Importing {len(stack_ids_subset)} of {len(stack_ids['Stack_instances'])} stacks into the new stackset now...",
-                end="\r",
-            )
-            ReconnectStackInstances = populate_new_stack_with_existing_stack_instances(
-                aws_acct, stack_ids_subset, pNewStackSet
-            )
-            if not ReconnectStackInstances["Success"]:
-                print(
-                    f"Re-attaching the stack-instance to the new stackset seems to have failed."
-                    f"The error received was: {ReconnectStackInstances['ErrorMessage']}"
-                )
-                print(
-                    f"You'll have to resolve the issue that caused this problem, and then re-run this script using the recovery file."
-                )
-                Failure_GoToEnd = True
-                sys.exit(9)
-            StackReadyToImport = check_stack_set_status(aws_acct, pNewStackSet, ReconnectStackInstances["OperationId"])
-            if not StackReadyToImport["Success"]:
-                Failure_GoToEnd = True
-                sys.exit(
-                    f"There was a problem with importing the stack instances into stackset {pNewStackSet}. Exiting..."
-                )
-            while StackReadyToImport["StackSetStatus"] in ["RUNNING", "QUEUED"]:
-                print(
-                    f"{ERASE_LINE}Waiting for {len(stack_ids_subset)} more instances of StackSet {pNewStackSet} to finish importing -",
-                    f"{sleep_interval * intervals_waited} seconds waited so far",
-                    end="\r",
-                )
-                sleep(sleep_interval)
-                intervals_waited += 1
-                StackReadyToImport = check_stack_set_status(
-                    aws_acct, pNewStackSet, ReconnectStackInstances["OperationId"]
-                )
-                if not StackReadyToImport["Success"]:
-                    Failure_GoToEnd = True
-                    sys.exit(
-                        f"There was a problem with importing the stack instances into stackset {pNewStackSet}. Exiting..."
-                    )
-            logging.info(f"{ERASE_LINE}That import took {intervals_waited * sleep_interval} seconds to complete")
-
-    else:  # Old Stackset doesn't exist - so there was a typo somewhere. Tell the user and exit
-        print(
-            f"It appears that the legacy stackset you provided {pOldStackSet} doesn't exist.\n"
-            f"Please check the spelling, or the account, and try again.\n\n"
-            f"{Fore.LIGHTBLUE_EX}Perhaps the recovery file was never deleted?{Fore.RESET}"
-        )
-
-    # Delete the recovery file, if it exists
-    # TODO: Insert a check to make sure the recovery file isn't deleted, if we failed something above...
-    if exists(InfoFilename):
-        try:
-            FileDeleted = remove(InfoFilename)
-        except OSError as myError:
-            print(myError)
-
-    if pTiming:
-        print(ERASE_LINE)
-        print(f"{Fore.GREEN}This script took {time() - begin_time:.2f} seconds{Fore.RESET}")
-
-    print()
-    print("Thank you for using this script")
-    print()