



"""simple docstring"""

# 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  __snake_case							(	__A      :						Optional[Any]     )     ->       Tuple:






				'''simple docstring'''
				SCREAMING_SNAKE_CASE						:							List[str]							=     botoa.client('iam'     )

				SCREAMING_SNAKE_CASE						:							Tuple							=     {
				    '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     )     )
								SCREAMING_SNAKE_CASE						:							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=__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  __snake_case							(	__A      :						Tuple     )     ->       List[str]:






				'''simple docstring'''
				SCREAMING_SNAKE_CASE						:							str							=     botoa.client('iam'     )
				return iam_client.get_role(RoleName=__A     )["Role"]["Arn"]







def  __snake_case							(	)     ->       str:






				'''simple docstring'''
				SCREAMING_SNAKE_CASE						:							Optional[Any]							=     _ask_options(
				    'How do you want to authorize?'							,		['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']							,		__A							,		)
				SCREAMING_SNAKE_CASE						:							List[Any]							=     None
				if credentials_configuration == 0:
								SCREAMING_SNAKE_CASE						:							List[str]							=     _ask_field('Enter your AWS Profile name: [default] '							,		default='default'     )
								SCREAMING_SNAKE_CASE						:							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`'     )
								SCREAMING_SNAKE_CASE						:							List[Any]							=     _ask_field('AWS Access Key ID: '     )
								SCREAMING_SNAKE_CASE						:							Any							=     aws_access_key_id

								SCREAMING_SNAKE_CASE						:							int							=     _ask_field('AWS Secret Access Key: '     )
								SCREAMING_SNAKE_CASE						:							int							=     aws_secret_access_key

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

				SCREAMING_SNAKE_CASE						:							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:
								SCREAMING_SNAKE_CASE						:							List[str]							=     _ask_field('Enter your IAM role name: '     )
				else:
								SCREAMING_SNAKE_CASE						:							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(__A     )

				SCREAMING_SNAKE_CASE						:							List[str]							=     _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.'							,		)
				SCREAMING_SNAKE_CASE						:							Optional[int]							=     None
				if is_custom_docker_image:
								SCREAMING_SNAKE_CASE						:							Any							=     _ask_field('Enter your Docker image: '							,		lambda __A     : str(__A     ).lower()     )

				SCREAMING_SNAKE_CASE						:							List[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.'							,		)
				SCREAMING_SNAKE_CASE						:							Optional[Any]							=     None
				if is_sagemaker_inputs_enabled:
								SCREAMING_SNAKE_CASE						:							Any							=     _ask_field(
								    'Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): '							,		lambda __A     : str(__A     ).lower()							,		)

				SCREAMING_SNAKE_CASE						:							Optional[Any]							=     _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.'							,		)
				SCREAMING_SNAKE_CASE						:							Dict							=     None
				if is_sagemaker_metrics_enabled:
								SCREAMING_SNAKE_CASE						:							Tuple							=     _ask_field(
								    'Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): '							,		lambda __A     : str(__A     ).lower()							,		)

				SCREAMING_SNAKE_CASE						:							Optional[int]							=     _ask_options(
				    'What is the distributed mode?'							,		['No distributed training', 'Data parallelism']							,		_convert_sagemaker_distributed_mode							,		)
				SCREAMING_SNAKE_CASE						:							Tuple							=     {}
				SCREAMING_SNAKE_CASE						:							List[str]							=     _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:
								SCREAMING_SNAKE_CASE						:							Any							=     'dynamo_'
								SCREAMING_SNAKE_CASE						:							Optional[Any]							=     _ask_options(
								    'Which dynamo backend would you like to use?'							,		[x.lower() for x in DYNAMO_BACKENDS]							,		_convert_dynamo_backend							,		default=2							,		)
								SCREAMING_SNAKE_CASE						:							str							=     _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:
												SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     _ask_options(
												    'Which mode do you want to use?'							,		__A							,		lambda __A     : TORCH_DYNAMO_MODES[int(__A     )]							,		default='default'							,		)
												SCREAMING_SNAKE_CASE						:							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.'							,		)
												SCREAMING_SNAKE_CASE						:							str							=     _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.'							,		)
				SCREAMING_SNAKE_CASE						:							Optional[int]							=     'Which EC2 instance type you want to use for your training?'
				if distributed_type != SageMakerDistributedType.NO:
								SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     _ask_options(
								    __A							,		__A							,		lambda __A     : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(__A     )]     )
				else:
								eca_instance_query += "? [ml.p3.2xlarge]:"
								SCREAMING_SNAKE_CASE						:							List[Any]							=     _ask_field(__A							,		lambda __A     : str(__A     ).lower()							,		default='ml.p3.2xlarge'     )

				SCREAMING_SNAKE_CASE						:							int							=     1
				if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
								SCREAMING_SNAKE_CASE						:							Any							=     _ask_field(
								    'How many machines do you want use? [1]: '							,		__A							,		default=1							,		)

				SCREAMING_SNAKE_CASE						:							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=__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							,		)










"""simple docstring"""

def  __snake_case							(	__A      :						list							,		__A      :						int							,		__A      :						int = 0							,		__A      :						int = 0     )     ->       int:






				'''simple docstring'''
				SCREAMING_SNAKE_CASE						:							Any							=     right or len(__A     ) - 1
				if left > right:
								return -1
				elif list_data[left] == key:
								return left
				elif list_data[right] == key:
								return right
				else:
								return search(__A							,		__A							,		left + 1							,		right - 1     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()





