


'''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       a__				( unittest.TestCase      ):







				"""simple docstring"""



				__UpperCamelCase    :		Any	=	MODEL_FOR_MASKED_LM_MAPPING
				__UpperCamelCase    :		Dict	=	TF_MODEL_FOR_MASKED_LM_MAPPING




				def 					_snake_case  (self		):
										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 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''sshleifer/tiny-distilroberta-base'''       ,			top_k=2       ,			framework='''tf'''		)
										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {'''sequence''': '''My name is grouped''', '''score''': 2.1e-05, '''token''': 3_80_15, '''token_str''': ''' grouped'''},
										        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-05, '''token''': 2_55_06, '''token_str''': ''' accuser'''},
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''The largest city in France is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {
										            '''sequence''': '''The largest city in France is grouped''',
										            '''score''': 2.1e-05,
										            '''token''': 3_80_15,
										            '''token_str''': ''' grouped''',
										        },
										        {
										            '''sequence''': '''The largest city in France is accuser''',
										            '''score''': 2.1e-05,
										            '''token''': 2_55_06,
										            '''token_str''': ''' accuser''',
										        },
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''       ,			targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,			top_k=3		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
										        {'''sequence''': '''My name is Patrick''', '''score''': 2e-05, '''token''': 34_99, '''token_str''': ''' Patrick'''},
										        {'''sequence''': '''My name is Te''', '''score''': 1.9e-05, '''token''': 29_41, '''token_str''': ''' Te'''},
										    ]       ,			)




				@require_torch
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''sshleifer/tiny-distilroberta-base'''       ,			top_k=2       ,			framework='''pt'''		)

										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {'''sequence''': '''My name is Maul''', '''score''': 2.2e-05, '''token''': 3_56_76, '''token_str''': ''' Maul'''},
										        {'''sequence''': '''My name isELS''', '''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS'''},
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''The largest city in France is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {
										            '''sequence''': '''The largest city in France is Maul''',
										            '''score''': 2.2e-05,
										            '''token''': 3_56_76,
										            '''token_str''': ''' Maul''',
										        },
										        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-05, '''token''': 1_64_16, '''token_str''': '''ELS'''},
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''       ,			targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,			top_k=3		)
										self.assertEqual(
										    nested_simplify(__lowercase       ,			decimals=6		)       ,			[
										        {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-05, '''token''': 34_99, '''token_str''': ''' Patrick'''},
										        {'''sequence''': '''My name is Te''', '''score''': 2e-05, '''token''': 29_41, '''token_str''': ''' Te'''},
										        {'''sequence''': '''My name is Clara''', '''score''': 2e-05, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''My name is <mask> <mask>'''       ,			top_k=2		)

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




				@require_torch_gpu
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline('''fill-mask'''       ,			model='''hf-internal-testing/tiny-random-distilbert'''       ,			device=0       ,			framework='''pt'''		)

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

										__lowerCAmelCase							       =				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(__lowercase       ,			__lowercase		)




				@slow
				@require_torch
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''distilroberta-base'''       ,			top_k=2       ,			framework='''pt'''		)
										self.run_large_test(__lowercase		)




				@slow
				@require_tf
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''distilroberta-base'''       ,			top_k=2       ,			framework='''tf'''		)
										self.run_large_test(__lowercase		)




				def 					_snake_case  (self       ,			__lowercase		):
										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase		)       ,			[
										        {'''sequence''': '''My name is John''', '''score''': 0.0_0_8, '''token''': 6_10, '''token_str''': ''' John'''},
										        {'''sequence''': '''My name is Chris''', '''score''': 0.0_0_7, '''token''': 15_73, '''token_str''': ''' Chris'''},
										    ]       ,			)
										__lowerCAmelCase							       =				unmasker('''The largest city in France is <mask>'''		)
										self.assertEqual(
										    nested_simplify(__lowercase		)       ,			[
										        {
										            '''sequence''': '''The largest city in France is Paris''',
										            '''score''': 0.2_5_1,
										            '''token''': 22_01,
										            '''token_str''': ''' Paris''',
										        },
										        {
										            '''sequence''': '''The largest city in France is Lyon''',
										            '''score''': 0.2_1_4,
										            '''token''': 1_27_90,
										            '''token_str''': ''' Lyon''',
										        },
										    ]       ,			)

										__lowerCAmelCase							       =				unmasker('''My name is <mask>'''       ,			targets=[''' Patrick''', ''' Clara''', ''' Teven''']       ,			top_k=3		)
										self.assertEqual(
										    nested_simplify(__lowercase		)       ,			[
										        {'''sequence''': '''My name is Patrick''', '''score''': 0.0_0_5, '''token''': 34_99, '''token_str''': ''' Patrick'''},
										        {'''sequence''': '''My name is Clara''', '''score''': 0.0_0_0, '''token''': 1_36_06, '''token_str''': ''' Clara'''},
										        {'''sequence''': '''My name is Te''', '''score''': 0.0_0_0, '''token''': 29_41, '''token_str''': ''' Te'''},
										    ]       ,			)




				@require_torch
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''sshleifer/tiny-distilroberta-base'''       ,			framework='''pt'''		)
										__lowerCAmelCase							       =				None
										__lowerCAmelCase							       =				None
										self.run_pipeline_test(__lowercase       ,			[]		)




				@require_tf
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				pipeline(task='''fill-mask'''       ,			model='''sshleifer/tiny-distilroberta-base'''       ,			framework='''tf'''		)
										__lowerCAmelCase							       =				None
										__lowerCAmelCase							       =				None
										self.run_pipeline_test(__lowercase       ,			[]		)




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

										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase		)
										__lowerCAmelCase							       =				[
										    F"""This is another {tokenizer.mask_token} test""",
										]
										return fill_masker, examples




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				fill_masker.tokenizer
										__lowerCAmelCase							       =				fill_masker.model

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

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

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

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

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




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

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

										# Score equivalence
										__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			targets=__lowercase		)
										__lowerCAmelCase							       =				[top_mask['''token_str'''] for top_mask in outputs]
										__lowerCAmelCase							       =				[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(__lowercase		) == set(__lowercase		):
																__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			targets=__lowercase		)
																__lowerCAmelCase							       =				[top_mask['''score'''] for top_mask in unmasked_targets]
																self.assertEqual(nested_simplify(__lowercase		)       ,			nested_simplify(__lowercase		)		)

										# Raises with invalid
										with self.assertRaises(__lowercase		):
																__lowerCAmelCase							       =				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(__lowercase		):
																						__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			targets=['''''']		)
																with self.assertRaises(__lowercase		):
																						__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			targets=''''''		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase       ,			top_k=2		)
										__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""		)
										self.assertEqual(
										    __lowercase       ,			[
										        {'''sequence''': ANY(__lowercase		), '''score''': ANY(__lowercase		), '''token''': ANY(__lowercase		), '''token_str''': ANY(__lowercase		)},
										        {'''sequence''': ANY(__lowercase		), '''score''': ANY(__lowercase		), '''token''': ANY(__lowercase		), '''token_str''': ANY(__lowercase		)},
										    ]       ,			)

										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase		)
										__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			top_k=2		)
										self.assertEqual(
										    __lowercase       ,			[
										        {'''sequence''': ANY(__lowercase		), '''score''': ANY(__lowercase		), '''token''': ANY(__lowercase		), '''token_str''': ANY(__lowercase		)},
										        {'''sequence''': ANY(__lowercase		), '''score''': ANY(__lowercase		), '''token''': ANY(__lowercase		), '''token_str''': ANY(__lowercase		)},
										    ]       ,			)
										self.assertEqual(nested_simplify(__lowercase		)       ,			nested_simplify(__lowercase		)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				tokenizer.get_vocab()
										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase		)

										# top_k=2, ntargets=3
										__lowerCAmelCase							       =				sorted(vocab.keys()		)[:3]
										__lowerCAmelCase							       =				fill_masker(F"""This is a {tokenizer.mask_token}"""       ,			top_k=2       ,			targets=__lowercase		)

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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase		)
										__lowerCAmelCase							       =				tokenizer.get_vocab()
										# String duplicates + id duplicates
										__lowerCAmelCase							       =				sorted(vocab.keys()		)[:3]
										__lowerCAmelCase							       =				[targets[0], targets[1], targets[0], targets[2], targets[1]]
										__lowerCAmelCase							       =				fill_masker(F"""My name is {tokenizer.mask_token}"""       ,			targets=__lowercase       ,			top_k=10		)

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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				FillMaskPipeline(model=__lowercase       ,			tokenizer=__lowercase		)

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







'''simple docstring'''

def 							__magic_name__(						):
						return [
						    a * b * (1_0_0_0 - a - b)
						    for a in range(1,				9_9_9)
						    for b in range(lowerCamelCase,				9_9_9)
						    if (a * a + b * b == (1_0_0_0 - a - b) ** 2)
						][0]


if __name__ == "__main__":
	print(f"""{solution() = }""")

