





# 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    _A	(   lowerCamelCase ):
   a__						:    Dict   		=	botoa.client("iam" )

   a__						:    str   		=	{
       "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 ) )
      a__						:    Dict   		=	{
          "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    _A	(   lowerCamelCase ):
   a__						:    Dict   		=	botoa.client("iam" )
   return iam_client.get_role(RoleName=lowerCamelCase )["Role"]["Arn"]






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

      a__						:    Tuple   		=	_ask_field("AWS Secret Access Key: " )
      a__						:    Union[str, Any]   		=	aws_secret_access_key

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

   a__						:    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"]				,			lowerCamelCase				,			)
   if role_management == 0:
      a__						:    Any   		=	_ask_field("Enter your IAM role name: " )
   else:
      a__						:    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 )

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

   a__						:    Optional[int]   		=	_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."				,			)
   a__						:    int   		=	None
   if is_sagemaker_inputs_enabled:
      a__						:    Dict   		=	_ask_field(
          "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "				,			lambda lowerCamelCase : str(lowerCamelCase ).lower()				,			)

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

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

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

   a__						:    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				,			)








import argparse
import os
import re


SCREAMING_SNAKE_CASE__							:      Any         =    """src/transformers/models/auto"""


# re pattern that matches mapping introductions:
#    SUPER_MODEL_MAPPING_NAMES = OrderedDict or SUPER_MODEL_MAPPING = OrderedDict
SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    re.compile(R"""[A-Z_]+_MAPPING(\s+|_[A-Z_]+\s+)=\s+OrderedDict""")
# re pattern that matches identifiers in mappings
SCREAMING_SNAKE_CASE__							:      Optional[int]         =    re.compile(R"""\s*\(\s*\"(\S[^\"]+)\"""")






def    _A	(   lowerCamelCase				,			lowerCamelCase = False ):
   with open(lowerCamelCase				,			"r"				,			encoding="utf-8" ) as f:
      a__						:    Optional[int]   		=	f.read()

   a__						:    Optional[Any]   		=	content.split("\n" )
   a__						:    Optional[int]   		=	[]
   a__						:    Optional[Any]   		=	0
   while line_idx < len(lowerCamelCase ):
      if _re_intro_mapping.search(lines[line_idx] ) is not None:
         a__						:    str   		=	len(re.search(r"^(\s*)\S"				,			lines[line_idx] ).groups()[0] ) + 8
         # Start of a new mapping!
         while not lines[line_idx].startswith(" " * indent + "(" ):
            new_lines.append(lines[line_idx] )
            line_idx += 1

         a__						:    Union[str, Any]   		=	[]
         while lines[line_idx].strip() != "]":
            # Blocks either fit in one line or not
            if lines[line_idx].strip() == "(":
               a__						:    int   		=	line_idx
               while not lines[line_idx].startswith(" " * indent + ")" ):
                  line_idx += 1
               blocks.append("\n".join(lines[start_idx : line_idx + 1] ) )
            else:
               blocks.append(lines[line_idx] )
            line_idx += 1

         # Sort blocks by their identifiers
         a__						:    Optional[Any]   		=	sorted(lowerCamelCase				,			key=lambda lowerCamelCase : _re_identifier.search(lowerCamelCase ).groups()[0] )
         new_lines += blocks
      else:
         new_lines.append(lines[line_idx] )
         line_idx += 1

   if overwrite:
      with open(lowerCamelCase				,			"w"				,			encoding="utf-8" ) as f:
         f.write("\n".join(lowerCamelCase ) )
   elif "\n".join(lowerCamelCase ) != content:
      return True






def    _A	(   lowerCamelCase = False ):
   a__						:    List[str]   		=	[os.path.join(lowerCamelCase				,			lowerCamelCase ) for f in os.listdir(lowerCamelCase ) if f.endswith(".py" )]
   a__						:    Any   		=	[sort_auto_mapping(lowerCamelCase				,			overwrite=lowerCamelCase ) for fname in fnames]

   if not overwrite and any(lowerCamelCase ):
      a__						:    Dict   		=	[f for f, d in zip(lowerCamelCase				,			lowerCamelCase ) if d]
      raise ValueError(
          F"""The following files have auto mappings that need sorting: {", ".join(lowerCamelCase )}. Run `make style` to fix"""
          " this." )


if __name__ == "__main__":
  SCREAMING_SNAKE_CASE__							:      Dict         =    argparse.ArgumentParser()
  parser.add_argument("""--check_only""", action="""store_true""", help="""Whether to only check or fix style.""")
  SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    parser.parse_args()

  sort_all_auto_mappings(not args.check_only)

