


'''simple docstring'''
import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class      lowercase			(							unittest.TestCase      ):

		"""simple docstring"""

		_a									=       MODEL_FOR_MASKED_LM_MAPPING
		_a									=       TF_MODEL_FOR_MASKED_LM_MAPPING




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							super().tearDown()
							# clean-up as much as possible GPU memory occupied by PyTorch
							gc.collect()
							if is_torch_available():
												import torch

												torch.cuda.empty_cache()




		@require_tf
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Optional[Any]							      =				pipeline(task='''fill-mask'''					,     model='''sshleifer/tiny-distilroberta-base'''					,     top_k=2					,     framework='''tf'''							)
							UpperCamelCase__     :Optional[int]							      =				unmasker('''My name is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {'''sequence''': '''My name is grouped''', '''score''': 2.1e-05, '''token''': 38015, '''token_str''': ''' grouped'''},
							        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-05, '''token''': 25506, '''token_str''': ''' accuser'''},
							    ]					,     )

							UpperCamelCase__     :List[Any]							      =				unmasker('''The largest city in France is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {
							            '''sequence''': '''The largest city in France is grouped''',
							            '''score''': 2.1e-05,
							            '''token''': 38015,
							            '''token_str''': ''' grouped''',
							        },
							        {
							            '''sequence''': '''The largest city in France is accuser''',
							            '''score''': 2.1e-05,
							            '''token''': 25506,
							            '''token_str''': ''' accuser''',
							        },
							    ]					,     )

							UpperCamelCase__     :Tuple							      =				unmasker('''My name is <mask>'''					,     targets=[''' Patrick''', ''' Clara''', ''' Teven''']					,     top_k=3							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 13606, '''token_str''': ''' Clara'''},
							        {'''sequence''': '''My name is Patrick''', '''score''': 2e-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
							        {'''sequence''': '''My name is Te''', '''score''': 1.9e-05, '''token''': 2941, '''token_str''': ''' Te'''},
							    ]					,     )




		@require_torch
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :str							      =				pipeline(task='''fill-mask'''					,     model='''sshleifer/tiny-distilroberta-base'''					,     top_k=2					,     framework='''pt'''							)

							UpperCamelCase__     :Tuple							      =				unmasker('''My name is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {'''sequence''': '''My name is Maul''', '''score''': 2.2e-05, '''token''': 35676, '''token_str''': ''' Maul'''},
							        {'''sequence''': '''My name isELS''', '''score''': 2.2e-05, '''token''': 16416, '''token_str''': '''ELS'''},
							    ]					,     )

							UpperCamelCase__     :str							      =				unmasker('''The largest city in France is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {
							            '''sequence''': '''The largest city in France is Maul''',
							            '''score''': 2.2e-05,
							            '''token''': 35676,
							            '''token_str''': ''' Maul''',
							        },
							        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-05, '''token''': 16416, '''token_str''': '''ELS'''},
							    ]					,     )

							UpperCamelCase__     :Optional[Any]							      =				unmasker('''My name is <mask>'''					,     targets=[''' Patrick''', ''' Clara''', ''' Teven''']					,     top_k=3							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-05, '''token''': 3499, '''token_str''': ''' Patrick'''},
							        {'''sequence''': '''My name is Te''', '''score''': 2e-05, '''token''': 2941, '''token_str''': ''' Te'''},
							        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 13606, '''token_str''': ''' Clara'''},
							    ]					,     )

							UpperCamelCase__     :List[str]							      =				unmasker('''My name is <mask> <mask>'''					,     top_k=2							)

							self.assertEqual(
							    nested_simplify(UpperCamelCase_					,     decimals=6							)					,     [
							        [
							            {
							                '''score''': 2.2e-05,
							                '''token''': 35676,
							                '''token_str''': ''' Maul''',
							                '''sequence''': '''<s>My name is Maul<mask></s>''',
							            },
							            {'''score''': 2.2e-05, '''token''': 16416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
							        ],
							        [
							            {
							                '''score''': 2.2e-05,
							                '''token''': 35676,
							                '''token_str''': ''' Maul''',
							                '''sequence''': '''<s>My name is<mask> Maul</s>''',
							            },
							            {'''score''': 2.2e-05, '''token''': 16416, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
							        ],
							    ]					,     )




		@require_torch_gpu
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Any							      =				pipeline('''fill-mask'''					,     model='''hf-internal-testing/tiny-random-distilbert'''					,     device=0					,     framework='''pt'''							)

							# convert model to fp16
							pipe.model.half()

							UpperCamelCase__     :List[str]							      =				pipe('''Paris is the [MASK] of France.'''							)
							# We actually don't care about the result, we just want to make sure
							# it works, meaning the float16 tensor got casted back to float32
							# for postprocessing.
							self.assertIsInstance(UpperCamelCase_					,     UpperCamelCase_							)




		@slow
		@require_torch
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :str							      =				pipeline(task='''fill-mask'''					,     model='''distilroberta-base'''					,     top_k=2					,     framework='''pt'''							)
							self.run_large_test(UpperCamelCase_							)




		@slow
		@require_tf
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Optional[Any]							      =				pipeline(task='''fill-mask'''					,     model='''distilroberta-base'''					,     top_k=2					,     framework='''tf'''							)
							self.run_large_test(UpperCamelCase_							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :int							      =				unmasker('''My name is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_							)					,     [
							        {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 610, '''token_str''': ''' John'''},
							        {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1573, '''token_str''': ''' Chris'''},
							    ]					,     )
							UpperCamelCase__     :Union[str, Any]							      =				unmasker('''The largest city in France is <mask>'''							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_							)					,     [
							        {
							            '''sequence''': '''The largest city in France is Paris''',
							            '''score''': 0.251,
							            '''token''': 2201,
							            '''token_str''': ''' Paris''',
							        },
							        {
							            '''sequence''': '''The largest city in France is Lyon''',
							            '''score''': 0.214,
							            '''token''': 12790,
							            '''token_str''': ''' Lyon''',
							        },
							    ]					,     )

							UpperCamelCase__     :Optional[int]							      =				unmasker('''My name is <mask>'''					,     targets=[''' Patrick''', ''' Clara''', ''' Teven''']					,     top_k=3							)
							self.assertEqual(
							    nested_simplify(UpperCamelCase_							)					,     [
							        {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 3499, '''token_str''': ''' Patrick'''},
							        {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 13606, '''token_str''': ''' Clara'''},
							        {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2941, '''token_str''': ''' Te'''},
							    ]					,     )




		@require_torch
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Union[str, Any]							      =				pipeline(task='''fill-mask'''					,     model='''sshleifer/tiny-distilroberta-base'''					,     framework='''pt'''							)
							UpperCamelCase__     :Union[str, Any]							      =				None
							UpperCamelCase__     :List[str]							      =				None
							self.run_pipeline_test(UpperCamelCase_					,     []							)




		@require_tf
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Tuple							      =				pipeline(task='''fill-mask'''					,     model='''sshleifer/tiny-distilroberta-base'''					,     framework='''tf'''							)
							UpperCamelCase__     :int							      =				None
							UpperCamelCase__     :Dict							      =				None
							self.run_pipeline_test(UpperCamelCase_					,     []							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							if tokenizer is None or tokenizer.mask_token_id is None:
												self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)'''							)

							UpperCamelCase__     :Union[str, Any]							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)
							UpperCamelCase__     :Any							      =				[
							    F'''This is another {tokenizer.mask_token} test''',
							]
							return fill_masker, examples




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :Union[str, Any]							      =				fill_masker.tokenizer
							UpperCamelCase__     :str							      =				fill_masker.model

							UpperCamelCase__     :Dict							      =				fill_masker(
							    F'''This is a {tokenizer.mask_token}'''					,     )
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )

							UpperCamelCase__     :List[str]							      =				fill_masker([F'''This is a {tokenizer.mask_token}''']							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )

							UpperCamelCase__     :Any							      =				fill_masker([F'''This is a {tokenizer.mask_token}''', F'''Another {tokenizer.mask_token} great test.''']							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        [
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        ],
							        [
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        ],
							    ]					,     )

							with self.assertRaises(UpperCamelCase_							):
												fill_masker([None]							)
							# No mask_token is not supported
							with self.assertRaises(UpperCamelCase_							):
												fill_masker('''This is'''							)

							self.run_test_top_k(UpperCamelCase_					,     UpperCamelCase_							)
							self.run_test_targets(UpperCamelCase_					,     UpperCamelCase_							)
							self.run_test_top_k_targets(UpperCamelCase_					,     UpperCamelCase_							)
							self.fill_mask_with_duplicate_targets_and_top_k(UpperCamelCase_					,     UpperCamelCase_							)
							self.fill_mask_with_multiple_masks(UpperCamelCase_					,     UpperCamelCase_							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :List[Any]							      =				tokenizer.get_vocab()
							UpperCamelCase__     :List[Any]							      =				sorted(vocab.keys()							)[:2]
							# Pipeline argument
							UpperCamelCase__     :Any							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_					,     targets=UpperCamelCase_							)
							UpperCamelCase__     :str							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )
							UpperCamelCase__     :int							      =				{vocab[el] for el in targets}
							self.assertEqual({el['''token'''] for el in outputs}					,     UpperCamelCase_							)
							UpperCamelCase__     :Any							      =				[tokenizer.decode([x]							) for x in target_ids]
							self.assertEqual({el['''token_str'''] for el in outputs}					,     set(UpperCamelCase_							)							)

							# Call argument
							UpperCamelCase__     :int							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)
							UpperCamelCase__     :str							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=UpperCamelCase_							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )
							UpperCamelCase__     :int							      =				{vocab[el] for el in targets}
							self.assertEqual({el['''token'''] for el in outputs}					,     UpperCamelCase_							)
							UpperCamelCase__     :Optional[Any]							      =				[tokenizer.decode([x]							) for x in target_ids]
							self.assertEqual({el['''token_str'''] for el in outputs}					,     set(UpperCamelCase_							)							)

							# Score equivalence
							UpperCamelCase__     :Dict							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=UpperCamelCase_							)
							UpperCamelCase__     :Dict							      =				[top_mask['''token_str'''] for top_mask in outputs]
							UpperCamelCase__     :str							      =				[top_mask['''score'''] for top_mask in outputs]

							# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
							if set(UpperCamelCase_							) == set(UpperCamelCase_							):
												UpperCamelCase__     :Optional[Any]							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=UpperCamelCase_							)
												UpperCamelCase__     :List[Any]							      =				[top_mask['''score'''] for top_mask in unmasked_targets]
												self.assertEqual(nested_simplify(UpperCamelCase_							)					,     nested_simplify(UpperCamelCase_							)							)

							# Raises with invalid
							with self.assertRaises(UpperCamelCase_							):
												UpperCamelCase__     :Dict							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=[]							)
							# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
							if "" not in tokenizer.get_vocab():
												with self.assertRaises(UpperCamelCase_							):
																	UpperCamelCase__     :str							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=['''''']							)
												with self.assertRaises(UpperCamelCase_							):
																	UpperCamelCase__     :Tuple							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     targets=''''''							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :Optional[Any]							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_					,     top_k=2							)
							UpperCamelCase__     :Optional[int]							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )

							UpperCamelCase__     :Union[str, Any]							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)
							UpperCamelCase__     :str							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     top_k=2							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							    ]					,     )
							self.assertEqual(nested_simplify(UpperCamelCase_							)					,     nested_simplify(UpperCamelCase_							)							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :Union[str, Any]							      =				tokenizer.get_vocab()
							UpperCamelCase__     :Tuple							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)

							# top_k=2, ntargets=3
							UpperCamelCase__     :List[Any]							      =				sorted(vocab.keys()							)[:3]
							UpperCamelCase__     :List[str]							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     top_k=2					,     targets=UpperCamelCase_							)

							# If we use the most probably targets, and filter differently, we should still
							# have the same results
							UpperCamelCase__     :Any							      =				[el['''token_str'''] for el in sorted(UpperCamelCase_					,     key=lambda UpperCamelCase_							: x["score"]					,     reverse=UpperCamelCase_							)]
							# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
							if set(UpperCamelCase_							).issubset(UpperCamelCase_							):
												UpperCamelCase__     :Optional[int]							      =				fill_masker(F'''This is a {tokenizer.mask_token}'''					,     top_k=3					,     targets=UpperCamelCase_							)
												# They should yield exactly the same result
												self.assertEqual(nested_simplify(UpperCamelCase_							)					,     nested_simplify(UpperCamelCase_							)							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :Tuple							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)
							UpperCamelCase__     :Union[str, Any]							      =				tokenizer.get_vocab()
							# String duplicates + id duplicates
							UpperCamelCase__     :int							      =				sorted(vocab.keys()							)[:3]
							UpperCamelCase__     :Union[str, Any]							      =				[targets[0], targets[1], targets[0], targets[2], targets[1]]
							UpperCamelCase__     :Union[str, Any]							      =				fill_masker(F'''My name is {tokenizer.mask_token}'''					,     targets=UpperCamelCase_					,     top_k=10							)

							# The target list contains duplicates, so we can't output more
							# than them
							self.assertEqual(len(UpperCamelCase_							)					,     3							)




		def 					lowerCAmelCase__       (	self					,     UpperCamelCase_					,     UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__     :Union[str, Any]							      =				FillMaskPipeline(model=UpperCamelCase_					,     tokenizer=UpperCamelCase_							)

							UpperCamelCase__     :int							      =				fill_masker(
							    F'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''					,     top_k=2							)
							self.assertEqual(
							    UpperCamelCase_					,     [
							        [
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        ],
							        [
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        ],
							        [
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							            {'''sequence''': ANY(UpperCamelCase_							), '''score''': ANY(UpperCamelCase_							), '''token''': ANY(UpperCamelCase_							), '''token_str''': ANY(UpperCamelCase_							)},
							        ],
							    ]					,     )



'''simple docstring'''
import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
		import torch
@require_torch
@require_optimum
@slow
class      lowercase			(							unittest.TestCase      ):

		"""simple docstring"""

		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Tuple							      =				'''hf-internal-testing/tiny-random-t5'''
							UpperCamelCase__     :int							      =				AutoTokenizer.from_pretrained(UpperCamelCase_							)
							UpperCamelCase__     :int							      =				AutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase_							)

							UpperCamelCase__     :int							      =				tokenizer('''This is me'''					,     return_tensors='''pt'''							)

							UpperCamelCase__     :Optional[int]							      =				model.to_bettertransformer()

							self.assertTrue(any('''BetterTransformer''' in mod.__class__.__name__ for _, mod in model.named_modules()							)							)

							UpperCamelCase__     :int							      =				model.generate(**UpperCamelCase_							)

							UpperCamelCase__     :Optional[Any]							      =				model.reverse_bettertransformer()

							self.assertFalse(any('''BetterTransformer''' in mod.__class__.__name__ for _, mod in model.named_modules()							)							)

							with tempfile.TemporaryDirectory() as tmpdirname:
												model.save_pretrained(UpperCamelCase_							)

												UpperCamelCase__     :Tuple							      =				AutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase_							)

												self.assertFalse(
												    any('''BetterTransformer''' in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()							)							)

												UpperCamelCase__     :Tuple							      =				model_reloaded.generate(**UpperCamelCase_							)
												self.assertTrue(torch.allclose(UpperCamelCase_					,     UpperCamelCase_							)							)




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :List[Any]							      =				'''hf-internal-testing/tiny-random-t5'''
							UpperCamelCase__     :Dict							      =				AutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase_							)

							UpperCamelCase__     :Union[str, Any]							      =				model.to_bettertransformer()

							with tempfile.TemporaryDirectory() as tmpdirname:
												with self.assertRaises(UpperCamelCase_							):
																	model.save_pretrained(UpperCamelCase_							)

												UpperCamelCase__     :Tuple							      =				model.reverse_bettertransformer()
												model.save_pretrained(UpperCamelCase_							)