





# 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__       (  snake_case__  :Dict     )      ->						Tuple:
  _lowercase							= botoa.client('iam'     )

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

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







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

    _lowercase							= _ask_field('AWS Secret Access Key: '     )
    _lowercase							= aws_secret_access_key

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

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

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

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

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

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

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

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

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






import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


snake_case 				=       get_tests_dir("""fixtures/test_sentencepiece_no_bos.model""")





@require_sentencepiece
@require_tokenizers
class 				A_				(      UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizer
       SCREAMING_SNAKE_CASE_      : Optional[int]      =  PegasusTokenizerFast
       SCREAMING_SNAKE_CASE_      : Any      =  True
       SCREAMING_SNAKE_CASE_      : Optional[int]      =  True







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Any:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _lowercase							= PegasusTokenizer(__A  )
         tokenizer.save_pretrained(self.tmpdirname  )







       @cached_property
       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					List[Any]:
         return PegasusTokenizer.from_pretrained('google/pegasus-large'  )







       def    __UpperCAmelCase (    self	:	Any						,**__A	:	int  )						->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname						,**__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,__A	:	int  )						->					List[str]:
         return ("This is a test", "This is a test")







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[Any]:
         _lowercase							= '</s>'
         _lowercase							= 1

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__A  )						,__A  )
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__A  )						,__A  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Optional[Any]:
         _lowercase							= list(self.get_tokenizer().get_vocab().keys()  )

         self.assertEqual(vocab_keys[0]						,'<pad>'  )
         self.assertEqual(vocab_keys[1]						,'</s>'  )
         self.assertEqual(vocab_keys[-1]						,'v'  )
         self.assertEqual(len(__A  )						,1103  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         self.assertEqual(self.get_tokenizer().vocab_size						,1103  )







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					List[str]:
         _lowercase							= self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= self.tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= (
             'Let\'s see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important'
             ' </s> <pad> <pad> <pad>'
         )
         _lowercase							= rust_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         _lowercase							= py_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					List[Any]:
         _lowercase							= self._large_tokenizer
         # <mask_1> masks whole sentence while <mask_2> masks single word
         _lowercase							= '<mask_1> To ensure a <mask_2> flow of bank resolutions.'
         _lowercase							= [2, 413, 615, 114, 3, 1971, 113, 1679, 1_0710, 107, 1]
         _lowercase							= tokenizer([raw_input_str]						,return_tensors=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       def    __UpperCAmelCase (    self	:	int  )						->					Union[str, Any]:
         _lowercase							= self._large_tokenizer
         # The tracebacks for the following asserts are **better** without messages or self.assertEqual
         assert tokenizer.vocab_size == 9_6103
         assert tokenizer.pad_token_id == 0
         assert tokenizer.eos_token_id == 1
         assert tokenizer.offset == 103
         assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
         assert tokenizer.unk_token == "<unk>"
         assert tokenizer.model_max_length == 1024
         _lowercase							= 'To ensure a smooth flow of bank resolutions.'
         _lowercase							= [413, 615, 114, 2291, 1971, 113, 1679, 1_0710, 107, 1]
         _lowercase							= tokenizer([raw_input_str]						,return_tensors=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )
         assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]  ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]







       @require_torch
       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					List[str]:
         _lowercase							= ['This is going to be way too long.' * 150, 'short example']
         _lowercase							= ['not super long but more than 5 tokens', 'tiny']
         _lowercase							= self._large_tokenizer(__A						,padding=__A						,truncation=__A						,return_tensors='pt'  )
         _lowercase							= self._large_tokenizer(
             text_target=__A						,max_length=5						,padding=__A						,truncation=__A						,return_tensors='pt'  )

         assert batch.input_ids.shape == (2, 1024)
         assert batch.attention_mask.shape == (2, 1024)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__A  ) == 2  # input_ids, attention_mask.







       @slow
       def    __UpperCAmelCase (    self	:	Dict  )						->					Optional[int]:
         # fmt: off
         _lowercase							= {'input_ids': [[3_8979, 143, 1_8485, 606, 130, 2_6669, 8_7686, 121, 5_4189, 1129, 111, 2_6669, 8_7686, 121, 9114, 1_4787, 121, 1_3249, 158, 592, 956, 121, 1_4621, 3_1576, 143, 6_2613, 108, 9688, 930, 4_3430, 1_1562, 6_2613, 304, 108, 1_1443, 897, 108, 9314, 1_7415, 6_3399, 108, 1_1443, 7614, 1_8316, 118, 4284, 7148, 1_2430, 143, 1400, 2_5703, 158, 111, 4284, 7148, 1_1772, 143, 2_1297, 1064, 158, 122, 204, 3506, 1754, 1133, 1_4787, 1581, 115, 3_3224, 4482, 111, 1355, 110, 2_9173, 317, 5_0833, 108, 2_0147, 9_4665, 111, 7_7198, 107, 1], [110, 6_2613, 117, 638, 112, 1133, 121, 2_0098, 1355, 7_9050, 1_3872, 135, 1596, 5_3541, 1352, 141, 1_3039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 1_8289, 1_7780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__A						,model_name='google/bigbird-pegasus-large-arxiv'						,revision='ba85d0851d708441f91440d509690f1ab6353415'						,)





@require_sentencepiece
@require_tokenizers
class 				A_				(      UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizer
       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizerFast
       SCREAMING_SNAKE_CASE_      : str      =  True
       SCREAMING_SNAKE_CASE_      : List[Any]      =  True







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[int]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _lowercase							= PegasusTokenizer(__A						,offset=0						,mask_token_sent=__A						,mask_token='[MASK]'  )
         tokenizer.save_pretrained(self.tmpdirname  )







       @cached_property
       def    __UpperCAmelCase (    self	:	str  )						->					Optional[Any]:
         return PegasusTokenizer.from_pretrained('google/bigbird-pegasus-large-arxiv'  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,**__A	:	Union[str, Any]  )						->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname						,**__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,__A	:	int  )						->					Tuple:
         return ("This is a test", "This is a test")







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Dict:
         _lowercase							= self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= self.tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= (
             'Let\'s see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>'
             ' <pad> <pad> <pad>'
         )
         _lowercase							= rust_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         _lowercase							= py_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       @require_torch
       def    __UpperCAmelCase (    self	:	List[str]  )						->					Dict:
         _lowercase							= ['This is going to be way too long.' * 1000, 'short example']
         _lowercase							= ['not super long but more than 5 tokens', 'tiny']
         _lowercase							= self._large_tokenizer(__A						,padding=__A						,truncation=__A						,return_tensors='pt'  )
         _lowercase							= self._large_tokenizer(
             text_target=__A						,max_length=5						,padding=__A						,truncation=__A						,return_tensors='pt'  )

         assert batch.input_ids.shape == (2, 4096)
         assert batch.attention_mask.shape == (2, 4096)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__A  ) == 2  # input_ids, attention_mask.







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					int:
         _lowercase							= (
             'This is an example string that is used to test the original TF implementation against the HF'
             ' implementation'
         )

         _lowercase							= self._large_tokenizer(__A  ).input_ids

         self.assertListEqual(
             __A						,[182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 2_5016, 3137, 464, 109, 2_6955, 3137, 1]						,)