





# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import os

from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES
from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
from ...utils.imports import is_botoa_available
from .config_args import SageMakerConfig
from .config_utils import (
    DYNAMO_BACKENDS,
    _ask_field,
    _ask_options,
    _convert_dynamo_backend,
    _convert_mixed_precision,
    _convert_sagemaker_distributed_mode,
    _convert_yes_no_to_bool,
)


if is_botoa_available():
    import botoa  # noqa: F401


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase				)    ->  Tuple:
    lowerCamelCase__					:   int      				=	botoa.client('iam'				)

    lowerCamelCase__					:   Union[str, Any]      				=	{
        'Version': '2012-10-17',
        'Statement': [
            {'Effect': 'Allow', 'Principal': {'Service': 'sagemaker.amazonaws.com'}, 'Action': 'sts:AssumeRole'}
        ],
    }
    try:
        # create the role, associated with the chosen trust policy
        iam_client.create_role(
            RoleName=_UpperCAmelCase		,			AssumeRolePolicyDocument=json.dumps(_UpperCAmelCase		,			indent=2				)				)
        lowerCamelCase__					:   Optional[Any]      				=	{
            'Version': '2012-10-17',
            'Statement': [
                {
                    'Effect': 'Allow',
                    'Action': [
                        'sagemaker:*',
                        'ecr:GetDownloadUrlForLayer',
                        'ecr:BatchGetImage',
                        'ecr:BatchCheckLayerAvailability',
                        'ecr:GetAuthorizationToken',
                        'cloudwatch:PutMetricData',
                        'cloudwatch:GetMetricData',
                        'cloudwatch:GetMetricStatistics',
                        'cloudwatch:ListMetrics',
                        'logs:CreateLogGroup',
                        'logs:CreateLogStream',
                        'logs:DescribeLogStreams',
                        'logs:PutLogEvents',
                        'logs:GetLogEvents',
                        's3:CreateBucket',
                        's3:ListBucket',
                        's3:GetBucketLocation',
                        's3:GetObject',
                        's3:PutObject',
                    ],
                    'Resource': '*',
                }
            ],
        }
        # attach policy to role
        iam_client.put_role_policy(
            RoleName=_UpperCAmelCase		,			PolicyName=F"""{role_name}_policy_permission"""		,			PolicyDocument=json.dumps(_UpperCAmelCase		,			indent=2				)		,			)
    except iam_client.exceptions.EntityAlreadyExistsException:
        print(F"""role {role_name} already exists. Using existing one"""				)


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase				)    ->  str:
    lowerCamelCase__					:   int      				=	botoa.client('iam'				)
    return iam_client.get_role(RoleName=_UpperCAmelCase				)["Role"]["Arn"]


def  SCREAMING_SNAKE_CASE   ( )    ->  Tuple:
    lowerCamelCase__					:   Dict      				=	_ask_options(
        'How do you want to authorize?'		,			['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']		,			_UpperCAmelCase		,			)
    lowerCamelCase__					:   Dict      				=	None
    if credentials_configuration == 0:
        lowerCamelCase__					:   Union[str, Any]      				=	_ask_field('Enter your AWS Profile name: [default] '		,			default='default'				)
        lowerCamelCase__					:   Optional[Any]      				=	aws_profile
    else:
        print(
            'Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,'
            '`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`'				)
        lowerCamelCase__					:   Dict      				=	_ask_field('AWS Access Key ID: '				)
        lowerCamelCase__					:   Tuple      				=	aws_access_key_id

        lowerCamelCase__					:   Any      				=	_ask_field('AWS Secret Access Key: '				)
        lowerCamelCase__					:   str      				=	aws_secret_access_key

    lowerCamelCase__					:   str      				=	_ask_field('Enter your AWS Region: [us-east-1]'		,			default='us-east-1'				)
    lowerCamelCase__					:   Dict      				=	aws_region

    lowerCamelCase__					:   List[Any]      				=	_ask_options(
        'Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?'		,			['Provide IAM Role name', 'Create new IAM role using credentials']		,			_UpperCAmelCase		,			)
    if role_management == 0:
        lowerCamelCase__					:   Dict      				=	_ask_field('Enter your IAM role name: '				)
    else:
        lowerCamelCase__					:   Tuple      				=	'accelerate_sagemaker_execution_role'
        print(F"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""				)
        _create_iam_role_for_sagemaker(_UpperCAmelCase				)

    lowerCamelCase__					:   Tuple      				=	_ask_field(
        'Do you want to use custom Docker image? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
    lowerCamelCase__					:   List[Any]      				=	None
    if is_custom_docker_image:
        lowerCamelCase__					:   Any      				=	_ask_field('Enter your Docker image: '		,			lambda _UpperCAmelCase				: str(_UpperCAmelCase				).lower()				)

    lowerCamelCase__					:   Optional[Any]      				=	_ask_field(
        'Do you want to provide SageMaker input channels with data locations? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
    lowerCamelCase__					:   Any      				=	None
    if is_sagemaker_inputs_enabled:
        lowerCamelCase__					:   Tuple      				=	_ask_field(
            'Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): '		,			lambda _UpperCAmelCase				: str(_UpperCAmelCase				).lower()		,			)

    lowerCamelCase__					:   List[str]      				=	_ask_field(
        'Do you want to enable SageMaker metrics? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
    lowerCamelCase__					:   Tuple      				=	None
    if is_sagemaker_metrics_enabled:
        lowerCamelCase__					:   Tuple      				=	_ask_field(
            'Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): '		,			lambda _UpperCAmelCase				: str(_UpperCAmelCase				).lower()		,			)

    lowerCamelCase__					:   int      				=	_ask_options(
        'What is the distributed mode?'		,			['No distributed training', 'Data parallelism']		,			_convert_sagemaker_distributed_mode		,			)
    lowerCamelCase__					:   Optional[Any]      				=	{}
    lowerCamelCase__					:   List[Any]      				=	_ask_field(
        'Do you wish to optimize your script with torch dynamo?[yes/NO]:'		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
    if use_dynamo:
        lowerCamelCase__					:   Any      				=	'dynamo_'
        lowerCamelCase__					:   Optional[int]      				=	_ask_options(
            'Which dynamo backend would you like to use?'		,			[x.lower() for x in DYNAMO_BACKENDS]		,			_convert_dynamo_backend		,			default=2		,			)
        lowerCamelCase__					:   str      				=	_ask_field(
            'Do you want to customize the defaults sent to torch.compile? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)

        if use_custom_options:
            lowerCamelCase__					:   Tuple      				=	_ask_options(
                'Which mode do you want to use?'		,			_UpperCAmelCase		,			lambda _UpperCAmelCase				: TORCH_DYNAMO_MODES[int(_UpperCAmelCase				)]		,			default='default'		,			)
            lowerCamelCase__					:   List[Any]      				=	_ask_field(
                'Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
            lowerCamelCase__					:   Dict      				=	_ask_field(
                'Do you want to enable dynamic shape tracing? [yes/NO]: '		,			_convert_yes_no_to_bool		,			default=_UpperCAmelCase		,			error_message='Please enter yes or no.'		,			)
    lowerCamelCase__					:   Dict      				=	'Which EC2 instance type you want to use for your training?'
    if distributed_type != SageMakerDistributedType.NO:
        lowerCamelCase__					:   Dict      				=	_ask_options(
            _UpperCAmelCase		,			_UpperCAmelCase		,			lambda _UpperCAmelCase				: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(_UpperCAmelCase				)]				)
    else:
        eca_instance_query += "? [ml.p3.2xlarge]:"
        lowerCamelCase__					:   Any      				=	_ask_field(_UpperCAmelCase		,			lambda _UpperCAmelCase				: str(_UpperCAmelCase				).lower()		,			default='ml.p3.2xlarge'				)

    lowerCamelCase__					:   str      				=	1
    if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
        lowerCamelCase__					:   Optional[int]      				=	_ask_field(
            'How many machines do you want use? [1]: '		,			_UpperCAmelCase		,			default=1		,			)

    lowerCamelCase__					:   List[Any]      				=	_ask_options(
        'Do you wish to use FP16 or BF16 (mixed precision)?'		,			['no', 'fp16', 'bf16', 'fp8']		,			_convert_mixed_precision		,			)

    if use_dynamo and mixed_precision == "no":
        print(
            'Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts.'				)

    return SageMakerConfig(
        image_uri=_UpperCAmelCase		,			compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER		,			distributed_type=_UpperCAmelCase		,			use_cpu=_UpperCAmelCase		,			dynamo_config=_UpperCAmelCase		,			eca_instance_type=_UpperCAmelCase		,			profile=_UpperCAmelCase		,			region=_UpperCAmelCase		,			iam_role_name=_UpperCAmelCase		,			mixed_precision=_UpperCAmelCase		,			num_machines=_UpperCAmelCase		,			sagemaker_inputs_file=_UpperCAmelCase		,			sagemaker_metrics_file=_UpperCAmelCase		,			)












from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase       : List[str]			     =       {
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : List[Any]			     =       [
        """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """AutoformerForPrediction""",
        """AutoformerModel""",
        """AutoformerPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_autoformer import (
        AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
        AutoformerConfig,
    )

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_autoformer import (
            AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            AutoformerForPrediction,
            AutoformerModel,
            AutoformerPreTrainedModel,
        )

else:
    import sys

    _UpperCAmelCase       : Dict			     =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





