






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






	"""simple docstring"""



	UpperCamelCase     :str          =	botoa.client("""iam"""					)

	UpperCamelCase     :Dict          =	{
	    """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=__magic_name__	,			AssumeRolePolicyDocument=json.dumps(__magic_name__	,			indent=2					)					)
		UpperCamelCase     :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=__magic_name__	,			PolicyName=f"""{role_name}_policy_permission"""	,			PolicyDocument=json.dumps(__magic_name__	,			indent=2					)	,			)
	except iam_client.exceptions.EntityAlreadyExistsException:
		print(f"""role {role_name} already exists. Using existing one"""					)

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  Optional[int]					)		->			int:






	"""simple docstring"""



	UpperCamelCase     :Any          =	botoa.client("""iam"""					)
	return iam_client.get_role(RoleName=__magic_name__					)["Role"]["Arn"]

def    SCREAMING_SNAKE_CASE_							(							)		->			Any:






	"""simple docstring"""



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

		UpperCamelCase     :Optional[Any]          =	_ask_field("""AWS Secret Access Key: """					)
		UpperCamelCase     :Dict          =	aws_secret_access_key

	UpperCamelCase     :Any          =	_ask_field("""Enter your AWS Region: [us-east-1]"""	,			default="""us-east-1"""					)
	UpperCamelCase     :Tuple          =	aws_region

	UpperCamelCase     :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"""]	,			__magic_name__	,			)
	if role_management == 0:
		UpperCamelCase     :str          =	_ask_field("""Enter your IAM role name: """					)
	else:
		UpperCamelCase     :List[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(__magic_name__					)

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

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

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

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

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

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

	UpperCamelCase     :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=__magic_name__	,			compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER	,			distributed_type=__magic_name__	,			use_cpu=__magic_name__	,			dynamo_config=__magic_name__	,			eca_instance_type=__magic_name__	,			profile=__magic_name__	,			region=__magic_name__	,			iam_role_name=__magic_name__	,			mixed_precision=__magic_name__	,			num_machines=__magic_name__	,			sagemaker_inputs_file=__magic_name__	,			sagemaker_metrics_file=__magic_name__	,			)







'''simple docstring'''

import functools





def 						UpperCamelCase				(							_lowerCamelCase					:					str						,       _lowerCamelCase					:					str       ):
    A__				=			len(_lowerCamelCase       )
    A__				=			len(_lowerCamelCase       )

    @functools.cache
    def min_distance(_lowerCamelCase					:					int						,       _lowerCamelCase					:					int       ) -> int:
        # if first word index is overflow - delete all from the second word
        if indexa >= len_worda:
            return len_worda - indexa
        # if second word index is overflow - delete all from the first word
        if indexa >= len_worda:
            return len_worda - indexa
        A__				=			int(worda[indexa] != worda[indexa]       )  # current letters not identical
        return min(
            1 + min_distance(indexa + 1						,       _lowerCamelCase       )						,       1 + min_distance(_lowerCamelCase						,       indexa + 1       )						,       diff + min_distance(indexa + 1						,       indexa + 1       )						,       )

    return min_distance(0						,       0       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()



