

# 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__       (  lowerCamelCase__			)  ->     Dict:
	__lowerCamelCase				:				Any					       = 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=a__	, AssumeRolePolicyDocument=json.dumps(a__	, indent=2			)			)
		__lowerCamelCase				:				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=a__	, PolicyName=F"{role_name}_policy_permission"	, PolicyDocument=json.dumps(a__	, indent=2			)	, )
	except iam_client.exceptions.EntityAlreadyExistsException:
		print(F"role {role_name} already exists. Using existing one"			)






def    SCREAMING_SNAKE_CASE__       (  lowerCamelCase__			)  ->     Optional[int]:
	__lowerCamelCase				:				Tuple					       = botoa.client('iam'			)
	return iam_client.get_role(RoleName=a__			)["Role"]["Arn"]






def    SCREAMING_SNAKE_CASE__       (  )  ->     Tuple:
	__lowerCamelCase				:				Optional[int]					       = _ask_options(
	    'How do you want to authorize?'	, ['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']	, a__	, )
	__lowerCamelCase				:				int					       = None
	if credentials_configuration == 0:
		__lowerCamelCase				:				List[Any]					       = _ask_field('Enter your AWS Profile name: [default] '	, default='default'			)
		__lowerCamelCase				:				Optional[int]					       = 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				:				Any					       = _ask_field('AWS Access Key ID: '			)
		__lowerCamelCase				:				Tuple					       = aws_access_key_id

		__lowerCamelCase				:				List[Any]					       = _ask_field('AWS Secret Access Key: '			)
		__lowerCamelCase				:				str					       = aws_secret_access_key

	__lowerCamelCase				:				Any					       = _ask_field('Enter your AWS Region: [us-east-1]'	, default='us-east-1'			)
	__lowerCamelCase				:				List[Any]					       = aws_region

	__lowerCamelCase				:				Tuple					       = _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']	, a__	, )
	if role_management == 0:
		__lowerCamelCase				:				Tuple					       = _ask_field('Enter your IAM role name: '			)
	else:
		__lowerCamelCase				:				Optional[Any]					       = 'accelerate_sagemaker_execution_role'
		print(F"Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"			)
		_create_iam_role_for_sagemaker(a__			)

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

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

	__lowerCamelCase				:				int					       = _ask_field(
	    'Do you want to enable SageMaker metrics? [yes/NO]: '	, _convert_yes_no_to_bool	, default=a__	, error_message='Please enter yes or no.'	, )
	__lowerCamelCase				:				Any					       = 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 lowerCamelCase__			: str(a__			).lower()	, )

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

		if use_custom_options:
			__lowerCamelCase				:				Optional[Any]					       = _ask_options(
			    'Which mode do you want to use?'	, a__	, lambda lowerCamelCase__			: TORCH_DYNAMO_MODES[int(a__			)]	, default='default'	, )
			__lowerCamelCase				:				Optional[int]					       = _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=a__	, error_message='Please enter yes or no.'	, )
			__lowerCamelCase				:				Optional[Any]					       = _ask_field(
			    'Do you want to enable dynamic shape tracing? [yes/NO]: '	, _convert_yes_no_to_bool	, default=a__	, error_message='Please enter yes or no.'	, )
	__lowerCamelCase				:				Optional[Any]					       = 'Which EC2 instance type you want to use for your training?'
	if distributed_type != SageMakerDistributedType.NO:
		__lowerCamelCase				:				str					       = _ask_options(
		    a__	, a__	, lambda lowerCamelCase__			: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(a__			)]			)
	else:
		eca_instance_query += "? [ml.p3.2xlarge]:"
		__lowerCamelCase				:				Union[str, Any]					       = _ask_field(a__	, lambda lowerCamelCase__			: str(a__			).lower()	, default='ml.p3.2xlarge'			)

	__lowerCamelCase				:				List[str]					       = 1
	if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
		__lowerCamelCase				:				str					       = _ask_field(
		    'How many machines do you want use? [1]: '	, a__	, default=1	, )

	__lowerCamelCase				:				List[str]					       = _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=a__	, compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER	, distributed_type=a__	, use_cpu=a__	, dynamo_config=a__	, eca_instance_type=a__	, profile=a__	, region=a__	, iam_role_name=a__	, mixed_precision=a__	, num_machines=a__	, sagemaker_inputs_file=a__	, sagemaker_metrics_file=a__	, )






from __future__ import annotations

import time
from collections.abc import Sequence
from random import randint

from matplotlib import pyplot as plt


def     __lowerCAmelCase			(			a__						,    a__						,    a__  )       ->  tuple[int | None, int | None, float]:
				if not arr:
								return None, None, 0
				if low == high:
								return low, high, arr[low]

				__a										=    (low + high) // 2
				__a							,     __a							,     __a										=    max_subarray(a__						,    a__						,    a__  )
				__a							,     __a							,     __a										=    max_subarray(a__						,    mid + 1						,    a__  )
				__a							,     __a							,     __a										=    max_cross_sum(a__						,    a__						,    a__						,    a__  )
				if left_sum >= right_sum and left_sum >= cross_sum:
								return left_low, left_high, left_sum
				elif right_sum >= left_sum and right_sum >= cross_sum:
								return right_low, right_high, right_sum
				return cross_left, cross_right, cross_sum


def     __lowerCAmelCase			(			a__						,    a__						,    a__						,    a__  )       ->  tuple[int, int, float]:
				__a							,     __a										=    float('''-inf'''  ), -1
				__a							,     __a										=    float('''-inf'''  ), -1

				__a										=    0
				for i in range(a__						,    low - 1						,    -1  ):
								summ += arr[i]
								if summ > left_sum:
												__a										=    summ
												__a										=    i

				__a										=    0
				for i in range(mid + 1						,    high + 1  ):
								summ += arr[i]
								if summ > right_sum:
												__a										=    summ
												__a										=    i

				return max_left, max_right, (left_sum + right_sum)


def     __lowerCAmelCase			(			a__  )       ->  float:
				__a										=    [randint(1						,    a__  ) for _ in range(a__  )]
				__a										=    time.time()
				max_subarray(a__						,    0						,    input_size - 1  )
				__a										=    time.time()
				return end - start


def     __lowerCAmelCase			(			)       ->  None:
				__a										=    [10, 100, 1000, 1_0000, 5_0000, 10_0000, 20_0000, 30_0000, 40_0000, 50_0000]
				__a										=    [time_max_subarray(a__  ) for input_size in input_sizes]
				print('''No of Inputs\t\tTime Taken'''  )
				for input_size, runtime in zip(a__						,    a__  ):
								print(a__						,    '''\t\t'''						,    a__  )
				plt.plot(a__						,    a__  )
				plt.xlabel('''Number of Inputs'''  )
				plt.ylabel('''Time taken in seconds'''  )
				plt.show()


if __name__ == "__main__":
					from doctest import testmod

					testmod()