

import argparse
import os
import re

import packaging.version


_UpperCAmelCase		:       int						    =	'examples/'
_UpperCAmelCase		:       Any						    =	{
    'examples': (re.compile(R"""^check_min_version\(\"[^\"]+\"\)\s*$""", re.MULTILINE), 'check_min_version("VERSION")\n'),
    'init': (re.compile(R"""^__version__\s+=\s+\"([^\"]+)\"\s*$""", re.MULTILINE), '__version__ = "VERSION"\n'),
    'setup': (re.compile(R"""^(\s*)version\s*=\s*\"[^\"]+\",""", re.MULTILINE), R'\1version="VERSION",'),
    'doc': (re.compile(R"""^(\s*)release\s*=\s*\"[^\"]+\"$""", re.MULTILINE), 'release = "VERSION"\n'),
}
_UpperCAmelCase		:       Dict						    =	{
    'init': 'src/transformers/__init__.py',
    'setup': 'setup.py',
}
_UpperCAmelCase		:       Any						    =	'README.md'





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							with open(a__       ,							'r'       ,							encoding='utf-8'       ,							newline='\n'				) as f:
														snake_case_          =   f.read()
							snake_case_    ,   snake_case_          =   REPLACE_PATTERNS[pattern]
							snake_case_          =   replace.replace('VERSION'       ,							a__				)
							snake_case_          =   re_pattern.sub(a__       ,							a__				)
							with open(a__       ,							'w'       ,							encoding='utf-8'       ,							newline='\n'				) as f:
														f.write(a__				)





def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							for folder, directories, fnames in os.walk(a__				):
														# Removing some of the folders with non-actively maintained examples from the walk
														if "research_projects" in directories:
																					directories.remove('research_projects'				)
														if "legacy" in directories:
																					directories.remove('legacy'				)
														for fname in fnames:
																					if fname.endswith('.py'				):
																												update_version_in_file(os.path.join(a__       ,							a__				)       ,							a__       ,							pattern='examples'				)





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__=False				):







							'''simple docstring'''






							for pattern, fname in REPLACE_FILES.items():
														update_version_in_file(a__       ,							a__       ,							a__				)
							if not patch:
														update_version_in_examples(a__				)





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   '🤗 Transformers currently provides the following architectures'
							snake_case_          =   '1. Want to contribute a new model?'
							with open(a__       ,							'r'       ,							encoding='utf-8'       ,							newline='\n'				) as f:
														snake_case_          =   f.readlines()

							# Find the start of the list.
							snake_case_          =   0
							while not lines[start_index].startswith(_start_prompt				):
														start_index += 1
							start_index += 1

							snake_case_          =   start_index
							# Update the lines in the model list.
							while not lines[index].startswith(_end_prompt				):
														if lines[index].startswith('1.'				):
																					snake_case_          =   lines[index].replace(
																					    'https://huggingface.co/docs/transformers/main/model_doc'       ,							'https://huggingface.co/docs/transformers/model_doc'       ,							)
														index += 1

							with open(a__       ,							'w'       ,							encoding='utf-8'       ,							newline='\n'				) as f:
														f.writelines(a__				)





def  __lowerCamelCase     (			):







							'''simple docstring'''






							with open(REPLACE_FILES['init']       ,							'r'				) as f:
														snake_case_          =   f.read()
							snake_case_          =   REPLACE_PATTERNS['init'][0].search(a__				).groups()[0]
							return packaging.version.parse(a__				)





def  __lowerCamelCase     (			UpperCamelCase__=False				):







							'''simple docstring'''






							snake_case_          =   get_version()
							if patch and default_version.is_devrelease:
														raise ValueError('Can\'t create a patch version from the dev branch, checkout a released version!'				)
							if default_version.is_devrelease:
														snake_case_          =   default_version.base_version
							elif patch:
														snake_case_          =   F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
							else:
														snake_case_          =   F'''{default_version.major}.{default_version.minor + 1}.0'''

							# Now let's ask nicely if that's the right one.
							snake_case_          =   input(F'''Which version are you releasing? [{default_version}]'''				)
							if len(a__				) == 0:
														snake_case_          =   default_version

							print(F'''Updating version to {version}.'''				)
							global_version_update(a__       ,							patch=a__				)
							if not patch:
														print('Cleaning main README, don\'t forget to run `make fix-copies`.'				)
														clean_main_ref_in_model_list()





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   get_version()
							snake_case_          =   F'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
							snake_case_          =   current_version.base_version

							# Check with the user we got that right.
							snake_case_          =   input(F'''Which version are we developing now? [{dev_version}]'''				)
							if len(a__				) == 0:
														snake_case_          =   dev_version

							print(F'''Updating version to {version}.'''				)
							global_version_update(a__				)
							print('Cleaning main README, don\'t forget to run `make fix-copies`.'				)
							clean_main_ref_in_model_list()


if __name__ == "__main__":
					_UpperCAmelCase		:       List[str]						    =	argparse.ArgumentParser()
					parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""")
					parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""")
					_UpperCAmelCase		:       Any						    =	parser.parse_args()
					if not args.post_release:
										pre_release_work(patch=args.patch)
					elif args.patch:
										print("""Nothing to do after a patch :-)""")
					else:
										post_release_work()







import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel







class 			lowercase    :




				def __init__( self				,       snake_case				,       snake_case=99				,       snake_case=13				,       snake_case=7				,       snake_case=9				,       snake_case=True				,       snake_case=True				,       snake_case=False				,       snake_case=32				,       snake_case=5				,       snake_case=4				,       snake_case=37				,       snake_case=8				,       snake_case=0.1				,       snake_case=0.0_02				,       snake_case=1				,       snake_case=0				,       snake_case=0				,       snake_case=None				,       snake_case=None				,       ):
											snake_case_          =   parent
											snake_case_          =   batch_size
											snake_case_          =   encoder_seq_length
											snake_case_          =   decoder_seq_length
											# For common tests
											snake_case_          =   self.decoder_seq_length
											snake_case_          =   is_training
											snake_case_          =   use_attention_mask
											snake_case_          =   use_labels
											snake_case_          =   vocab_size
											snake_case_          =   hidden_size
											snake_case_          =   num_hidden_layers
											snake_case_          =   num_attention_heads
											snake_case_          =   d_ff
											snake_case_          =   relative_attention_num_buckets
											snake_case_          =   dropout_rate
											snake_case_          =   initializer_factor
											snake_case_          =   eos_token_id
											snake_case_          =   pad_token_id
											snake_case_          =   decoder_start_token_id
											snake_case_          =   None
											snake_case_          =   decoder_layers




				def    a							( self	):
											return TaConfig.from_pretrained('google/umt5-base'	)




				def    a							( self				,       snake_case				,       snake_case				,       snake_case				,       snake_case=None				,       snake_case=None				,       snake_case=None				,       snake_case=None				,       snake_case=None				,       ):
											if attention_mask is None:
																		snake_case_          =   input_ids.ne(config.pad_token_id	)
											if decoder_attention_mask is None:
																		snake_case_          =   decoder_input_ids.ne(config.pad_token_id	)
											if head_mask is None:
																		snake_case_          =   torch.ones(config.num_hidden_layers				,       config.num_attention_heads				,       device=snake_case	)
											if decoder_head_mask is None:
																		snake_case_          =   torch.ones(config.num_decoder_layers				,       config.num_attention_heads				,       device=snake_case	)
											if cross_attn_head_mask is None:
																		snake_case_          =   torch.ones(
																		    config.num_decoder_layers				,       config.num_attention_heads				,       device=snake_case	)
											return {
											    "input_ids": input_ids,
											    "decoder_input_ids": decoder_input_ids,
											    "attention_mask": attention_mask,
											    "decoder_attention_mask": decoder_attention_mask,
											    "head_mask": head_mask,
											    "decoder_head_mask": decoder_head_mask,
											    "cross_attn_head_mask": cross_attn_head_mask,
											}




				def    a							( self	):
											snake_case_          =   ids_tensor([self.batch_size, self.encoder_seq_length]				,       self.vocab_size	)
											snake_case_          =   ids_tensor([self.batch_size, self.decoder_seq_length]				,       self.vocab_size	)

											# we need to clamp the input ids here to avoid having pad token in between
											# this is because for NllbMoe the position_ids are prepared such that
											# all pad tokens have pos id = 2 and rest are between 2..seq_length
											# and the seq_length here is seq_length - num_pad_tokens
											# but when using past, there is no way of knowing if the past input ids had
											# pad tokens in them, which results in incorrect seq_lenth and which in turn results in
											# position_ids being off by num_pad_tokens in past input
											snake_case_          =   input_ids.clamp(self.pad_token_id + 1	)
											snake_case_          =   decoder_input_ids.clamp(self.pad_token_id + 1	)

											snake_case_          =   self.get_config()
											snake_case_          =   config.num_attention_heads
											snake_case_          =   self.prepare_inputs_dict(snake_case				,       snake_case				,       snake_case	)
											return config, input_dict




				def    a							( self	):
											snake_case_    ,   snake_case_          =   self.prepare_config_and_inputs()
											return config, inputs_dict




				def    a							( self	):
											return TaConfig(
											    vocab_size=166				,       d_model=self.hidden_size				,       d_ff=self.d_ff				,       d_kv=self.hidden_size // self.num_attention_heads				,       num_layers=self.num_hidden_layers				,       num_decoder_layers=self.decoder_layers				,       num_heads=self.num_attention_heads				,       relative_attention_num_buckets=self.relative_attention_num_buckets				,       dropout_rate=self.dropout_rate				,       initializer_factor=self.initializer_factor				,       eos_token_id=self.eos_token_id				,       bos_token_id=self.pad_token_id				,       pad_token_id=self.pad_token_id				,       decoder_start_token_id=self.decoder_start_token_id				,       )




				def    a							( self	):
											return TaConfig(
											    vocab_size=self.vocab_size				,       d_model=self.hidden_size				,       d_ff=self.d_ff				,       d_kv=self.hidden_size // self.num_attention_heads				,       num_layers=self.num_hidden_layers				,       num_decoder_layers=self.decoder_layers				,       num_heads=self.num_attention_heads				,       relative_attention_num_buckets=self.relative_attention_num_buckets				,       dropout_rate=self.dropout_rate				,       initializer_factor=self.initializer_factor				,       eos_token_id=self.eos_token_id				,       bos_token_id=self.pad_token_id				,       pad_token_id=self.pad_token_id				,       decoder_start_token_id=self.decoder_start_token_id				,       )




				def    a							( self				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       ):
											snake_case_          =   UMTaModel(config=snake_case	)
											model.to(snake_case	)
											model.eval()
											snake_case_          =   model(
											    input_ids=snake_case				,       decoder_input_ids=snake_case				,       attention_mask=snake_case				,       decoder_attention_mask=snake_case				,       )
											snake_case_          =   model(input_ids=snake_case				,       decoder_input_ids=snake_case	)
											snake_case_          =   result.last_hidden_state
											snake_case_          =   result.past_key_values
											snake_case_          =   result.encoder_last_hidden_state

											self.parent.assertEqual(encoder_output.size()				,       (self.batch_size, self.encoder_seq_length, self.hidden_size)	)
											self.parent.assertEqual(decoder_output.size()				,       (self.batch_size, self.decoder_seq_length, self.hidden_size)	)
											# There should be `num_layers` key value embeddings stored in decoder_past
											self.parent.assertEqual(len(snake_case	)				,       config.num_layers	)
											# There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
											self.parent.assertEqual(len(decoder_past[0]	)				,       4	)




				def    a							( self				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       snake_case				,       ):
											snake_case_          =   UMTaModel(config=snake_case	).get_decoder().to(snake_case	).eval()
											# first forward pass
											snake_case_          =   model(snake_case				,       use_cache=snake_case	)
											snake_case_          =   model(snake_case	)
											snake_case_          =   model(snake_case				,       use_cache=snake_case	)

											self.parent.assertTrue(len(snake_case	) == len(snake_case	)	)
											self.parent.assertTrue(len(snake_case	) == len(snake_case	) + 1	)

											snake_case_    ,   snake_case_          =   outputs.to_tuple()

											# create hypothetical next token and extent to next_input_ids
											snake_case_          =   ids_tensor((self.batch_size, 1)				,       config.vocab_size	)

											# append to next input_ids and
											snake_case_          =   torch.cat([input_ids, next_tokens]				,       dim=-1	)

											snake_case_          =   model(snake_case	)['last_hidden_state']
											snake_case_          =   model(snake_case				,       past_key_values=snake_case	)['last_hidden_state']

											# select random slice
											snake_case_          =   ids_tensor((1,)				,       output_from_past.shape[-1]	).item()
											snake_case_          =   output_from_no_past[:, -1, random_slice_idx].detach()
											snake_case_          =   output_from_past[:, 0, random_slice_idx].detach()

											# test that outputs are equal for slice
											self.parent.assertTrue(torch.allclose(snake_case				,       snake_case				,       atol=1e-3	)	)




				def    a							( self				,       snake_case				,       snake_case				,       ):
											snake_case_          =   UMTaModel(config=snake_case	).to(snake_case	).half().eval()
											snake_case_          =   model(**snake_case	)['last_hidden_state']
											self.parent.assertFalse(torch.isnan(snake_case	).any().item()	)







@require_torch
class 			lowercase    (	lowercase_     ,  lowercase_     ,  lowercase_     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      (
				    (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
				)
				__SCREAMING_SNAKE_CASE :			int	      =      (UMTaForConditionalGeneration,) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      (
				    {
				        '''conversational''': UMTaForConditionalGeneration,
				        '''feature-extraction''': UMTaModel,
				        '''summarization''': UMTaForConditionalGeneration,
				        '''text2text-generation''': UMTaForConditionalGeneration,
				        '''translation''': UMTaForConditionalGeneration,
				        '''question-answering''': UMTaForQuestionAnswering,
				    }
				    if is_torch_available()
				    else {}
				)
				__SCREAMING_SNAKE_CASE :			List[str]	      =      True
				__SCREAMING_SNAKE_CASE :			str	      =      False
				__SCREAMING_SNAKE_CASE :			int	      =      False
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      True
				__SCREAMING_SNAKE_CASE :			Any	      =      True
				# The small UMT5 model needs higher percentages for CPU/MP tests
				__SCREAMING_SNAKE_CASE :			List[str]	      =      [0.8, 0.9]




				def    a							( self	):
											snake_case_          =   UMTaModelTester(self	)




				@unittest.skip('Test has a segmentation fault on torch 1.8.0'	)
				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs()
											snake_case_          =   UMTaModel(config_and_inputs[0]	).to(snake_case	)
											with tempfile.TemporaryDirectory() as tmpdirname:
																		torch.onnx.export(
																		    snake_case				,       (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2])				,       F'''{tmpdirname}/t5_test.onnx'''				,       export_params=snake_case				,       opset_version=9				,       input_names=['input_ids', 'decoder_input_ids']				,       )




				@unittest.skipIf(torch_device == 'cpu'				,       'Cant do half precision'	)
				def    a							( self	):
											snake_case_          =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model_fpaa_forward(*snake_case	)




				def    a							( self	):
											snake_case_          =   ['encoder_attentions', 'decoder_attentions', 'cross_attentions']
											snake_case_          =   self.model_tester.prepare_config_and_inputs()
											snake_case_          =   config_and_inputs[0]
											snake_case_          =   UMTaForConditionalGeneration(snake_case	).eval()
											model.to(snake_case	)

											snake_case_          =   {
											    'head_mask': torch.zeros(config.num_layers				,       config.num_heads				,       device=snake_case	),
											    'decoder_head_mask': torch.zeros(config.num_decoder_layers				,       config.num_heads				,       device=snake_case	),
											    'cross_attn_head_mask': torch.zeros(config.num_decoder_layers				,       config.num_heads				,       device=snake_case	),
											}

											for attn_name, (name, mask) in zip(snake_case				,       head_masking.items()	):
																		snake_case_          =   {name: mask}
																		# Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
																		if name == "head_mask":
																									snake_case_          =   torch.ones(
																									    config.num_decoder_layers				,       config.num_heads				,       device=snake_case	)

																		snake_case_          =   model.generate(
																		    config_and_inputs[1]['input_ids']				,       num_beams=1				,       max_length=3				,       output_attentions=snake_case				,       return_dict_in_generate=snake_case				,       **snake_case				,       )
																		# We check the state of decoder_attentions and cross_attentions just from the last step
																		snake_case_          =   out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
																		self.assertEqual(sum([w.sum().item() for w in attn_weights]	)				,       0.0	)




				@unittest.skip('Does not work on the tiny model as we keep hitting edge cases.'	)
				def    a							( self	):
											pass







@require_torch
@require_sentencepiece
@require_tokenizers
class 			lowercase    (	unittest.TestCase      ):




				@slow
				@unittest.skip(
				    'Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged'	)
				def    a							( self	):
											snake_case_          =   UMTaForConditionalGeneration.from_pretrained('google/umt5-small'				,       return_dict=snake_case	).to(snake_case	)
											snake_case_          =   AutoTokenizer.from_pretrained('google/umt5-small'				,       use_fast=snake_case				,       legacy=snake_case	)
											snake_case_          =   [
											    'Bonjour monsieur <extra_id_0> bien <extra_id_1>.',
											    'No se como puedo <extra_id_0>.',
											    'This is the reason why we <extra_id_0> them.',
											    'The <extra_id_0> walks in <extra_id_1>, seats',
											    'A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.',
											]
											snake_case_          =   tokenizer(snake_case				,       return_tensors='pt'				,       padding=snake_case	).input_ids
											# fmt: off
											snake_case_          =   torch.tensor(
											    [
											        [ 3_8530, 21_0703, 25_6299, 1410, 25_6298, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
											        [   826, 321, 671, 2_5922, 25_6299, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
											        [  1460, 339, 312, 1_9014, 1_0620, 758, 25_6299, 2355,274, 1, 0, 0, 0, 0, 0, 0,0, 0],
											        [   517, 25_6299, 1_4869, 281, 301, 25_6298, 275, 11_9983,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
											        [   320, 25_6299, 1_4869, 281, 2234, 289, 2275, 333,6_1391, 289, 25_6298, 543, 25_6297, 16_8714, 329, 25_6296,274, 1],
											    ]	)
											# fmt: on
											torch.testing.assert_allclose(snake_case				,       snake_case	)

											snake_case_          =   model.generate(input_ids.to(snake_case	)	)
											snake_case_          =   [
											    '<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>',
											    '<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
											    '<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
											    '<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
											    '<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
											]
											snake_case_          =   tokenizer.batch_decode(snake_case	)
											self.assertEqual(snake_case				,       snake_case	)




