






# 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_						(   lowerCAmelCase_				:  Optional[Any]					):
							__lowercase					:							Any			=   botoa.client("""iam"""					)

							__lowercase					:							int			=   {
							    """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=lowerCAmelCase_				,				AssumeRolePolicyDocument=json.dumps(lowerCAmelCase_				,				indent=2					)					)
														__lowercase					:							List[str]			=   {
														    """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=lowerCAmelCase_				,				PolicyName=F"{role_name}_policy_permission"				,				PolicyDocument=json.dumps(lowerCAmelCase_				,				indent=2					)				,				)
							except iam_client.exceptions.EntityAlreadyExistsException:
														print(F"role {role_name} already exists. Using existing one"					)
def 					snake_case_						(   lowerCAmelCase_				:  List[Any]					):
							__lowercase					:							int			=   botoa.client("""iam"""					)
							return iam_client.get_role(RoleName=lowerCAmelCase_					)["Role"]["Arn"]



def 					snake_case_						(   ):
							__lowercase					:							Optional[int]			=   _ask_options(
							    """How do you want to authorize?"""				,				["""AWS Profile""", """Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) """]				,				lowerCAmelCase_				,				)
							__lowercase					:							int			=   None
							if credentials_configuration == 0:
														__lowercase					:							int			=   _ask_field("""Enter your AWS Profile name: [default] """				,				default="""default"""					)
														__lowercase					:							Dict			=   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`"""					)
														__lowercase					:							Tuple			=   _ask_field("""AWS Access Key ID: """					)
														__lowercase					:							int			=   aws_access_key_id

														__lowercase					:							List[Any]			=   _ask_field("""AWS Secret Access Key: """					)
														__lowercase					:							Tuple			=   aws_secret_access_key

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

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

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

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

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

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

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

							__lowercase					:							Optional[Any]			=   1
							if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
														__lowercase					:							Dict			=   _ask_field(
														    """How many machines do you want use? [1]: """				,				lowerCAmelCase_				,				default=1				,				)

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







from __future__ import annotations

import math

lowerCamelCase       :       List[Any]        =				'''2020.9.26'''
lowerCamelCase       :       str        =				'''xcodz-dot, cclaus, dhruvmanila'''
def 					snake_case_						(   lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float					):
							if not all(isinstance(lowerCAmelCase_				,				(float, int)					) for val in locals().values()					):
														__lowercase					:							str			=   F"Input values must either be float or int: {list(locals().values()					)}"
														raise TypeError(lowerCAmelCase_					)
							__lowercase					:							List[Any]			=   ((x * distance) / (z + distance)) * scale
							__lowercase					:							Tuple			=   ((y * distance) / (z + distance)) * scale
							return projected_x, projected_y
def 					snake_case_						(   lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  float				,				lowerCAmelCase_				:  str				,				lowerCAmelCase_				:  float					):
							if not isinstance(lowerCAmelCase_				,				lowerCAmelCase_					):
														raise TypeError("""Axis must be a str"""					)
							__lowercase					:							Optional[int]			=   locals()
							del input_variables["axis"]
							if not all(isinstance(lowerCAmelCase_				,				(float, int)					) for val in input_variables.values()					):
														__lowercase					:							List[str]			=   (
														    """Input values except axis must either be float or int: """
														    F"{list(input_variables.values()					)}"
														)
														raise TypeError(lowerCAmelCase_					)
							__lowercase					:							Tuple			=   (angle % 360) / 450 * 180 / math.pi
							if axis == "z":
														__lowercase					:							int			=   x * math.cos(lowerCAmelCase_					) - y * math.sin(lowerCAmelCase_					)
														__lowercase					:							Tuple			=   y * math.cos(lowerCAmelCase_					) + x * math.sin(lowerCAmelCase_					)
														__lowercase					:							Union[str, Any]			=   z
							elif axis == "x":
														__lowercase					:							str			=   y * math.cos(lowerCAmelCase_					) - z * math.sin(lowerCAmelCase_					)
														__lowercase					:							Dict			=   z * math.cos(lowerCAmelCase_					) + y * math.sin(lowerCAmelCase_					)
														__lowercase					:							List[str]			=   x
							elif axis == "y":
														__lowercase					:							List[str]			=   x * math.cos(lowerCAmelCase_					) - z * math.sin(lowerCAmelCase_					)
														__lowercase					:							List[str]			=   z * math.cos(lowerCAmelCase_					) + x * math.sin(lowerCAmelCase_					)
														__lowercase					:							List[Any]			=   y
							else:
														raise ValueError("""not a valid axis, choose one of 'x', 'y', 'z'"""					)

							return new_x, new_y, new_z


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(f'''{convert_to_ad(1.0, 2.0, 3.0, 10.0, 10.0) = }''')
	print(f'''{rotate(1.0, 2.0, 3.0, "y", 90.0) = }''')