
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	):
							lowercase_ : Dict       =MODEL_FOR_MASKED_LM_MAPPING
							lowercase_ : Optional[int]       =TF_MODEL_FOR_MASKED_LM_MAPPING




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

												lowercase					=		unmasker('''The largest city in France is <mask>''')
												self.assertEqual(
												    nested_simplify(A__     ,decimals=6)     ,[
												        {
												            '''sequence''': '''The largest city in France is grouped''',
												            '''score''': 2.1E-05,
												            '''token''': 3_8_0_1_5,
												            '''token_str''': ''' grouped''',
												        },
												        {
												            '''sequence''': '''The largest city in France is accuser''',
												            '''score''': 2.1E-05,
												            '''token''': 2_5_5_0_6,
												            '''token_str''': ''' accuser''',
												        },
												    ]     ,)

												lowercase					=		unmasker('''My name is <mask>'''     ,targets=[''' Patrick''', ''' Clara''', ''' Teven''']     ,top_k=3)
												self.assertEqual(
												    nested_simplify(A__     ,decimals=6)     ,[
												        {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
												        {'''sequence''': '''My name is Patrick''', '''score''': 2E-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Te''', '''score''': 1.9E-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
												    ]     ,)




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

												lowercase					=		unmasker('''My name is <mask>''')
												self.assertEqual(
												    nested_simplify(A__     ,decimals=6)     ,[
												        {'''sequence''': '''My name is Maul''', '''score''': 2.2E-05, '''token''': 3_5_6_7_6, '''token_str''': ''' Maul'''},
												        {'''sequence''': '''My name isELS''', '''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
												    ]     ,)

												lowercase					=		unmasker('''The largest city in France is <mask>''')
												self.assertEqual(
												    nested_simplify(A__     ,decimals=6)     ,[
												        {
												            '''sequence''': '''The largest city in France is Maul''',
												            '''score''': 2.2E-05,
												            '''token''': 3_5_6_7_6,
												            '''token_str''': ''' Maul''',
												        },
												        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2E-05, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
												    ]     ,)

												lowercase					=		unmasker('''My name is <mask>'''     ,targets=[''' Patrick''', ''' Clara''', ''' Teven''']     ,top_k=3)
												self.assertEqual(
												    nested_simplify(A__     ,decimals=6)     ,[
												        {'''sequence''': '''My name is Patrick''', '''score''': 2.1E-05, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Te''', '''score''': 2E-05, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
												        {'''sequence''': '''My name is Clara''', '''score''': 2E-05, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
												    ]     ,)

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

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




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

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

												lowercase					=		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(A__     ,A__)




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




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




							def 				A__   (       self     ,A__):
												lowercase					=		unmasker('''My name is <mask>''')
												self.assertEqual(
												    nested_simplify(A__)     ,[
												        {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 6_1_0, '''token_str''': ''' John'''},
												        {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1_5_7_3, '''token_str''': ''' Chris'''},
												    ]     ,)
												lowercase					=		unmasker('''The largest city in France is <mask>''')
												self.assertEqual(
												    nested_simplify(A__)     ,[
												        {
												            '''sequence''': '''The largest city in France is Paris''',
												            '''score''': 0.251,
												            '''token''': 2_2_0_1,
												            '''token_str''': ''' Paris''',
												        },
												        {
												            '''sequence''': '''The largest city in France is Lyon''',
												            '''score''': 0.214,
												            '''token''': 1_2_7_9_0,
												            '''token_str''': ''' Lyon''',
												        },
												    ]     ,)

												lowercase					=		unmasker('''My name is <mask>'''     ,targets=[''' Patrick''', ''' Clara''', ''' Teven''']     ,top_k=3)
												self.assertEqual(
												    nested_simplify(A__)     ,[
												        {'''sequence''': '''My name is Patrick''', '''score''': 0.005, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
												        {'''sequence''': '''My name is Clara''', '''score''': 0.000, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
												        {'''sequence''': '''My name is Te''', '''score''': 0.000, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
												    ]     ,)




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




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




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

												lowercase					=		FillMaskPipeline(model=A__     ,tokenizer=A__)
												lowercase					=		[
												    f'This is another {tokenizer.mask_token} test',
												]
												return fill_masker, examples




							def 				A__   (       self     ,A__     ,A__):
												lowercase					=		fill_masker.tokenizer
												lowercase					=		fill_masker.model

												lowercase					=		fill_masker(
												    f'This is a {tokenizer.mask_token}'     ,)
												self.assertEqual(
												    A__     ,[
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												    ]     ,)

												lowercase					=		fill_masker([f'This is a {tokenizer.mask_token}'])
												self.assertEqual(
												    A__     ,[
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												    ]     ,)

												lowercase					=		fill_masker([f'This is a {tokenizer.mask_token}', f'Another {tokenizer.mask_token} great test.'])
												self.assertEqual(
												    A__     ,[
												        [
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        ],
												        [
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        ],
												    ]     ,)

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

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




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

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

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

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




							def 				A__   (       self     ,A__     ,A__):
												lowercase					=		FillMaskPipeline(model=A__     ,tokenizer=A__     ,top_k=2)
												lowercase					=		fill_masker(f'This is a {tokenizer.mask_token}')
												self.assertEqual(
												    A__     ,[
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												    ]     ,)

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




							def 				A__   (       self     ,A__     ,A__):
												lowercase					=		tokenizer.get_vocab()
												lowercase					=		FillMaskPipeline(model=A__     ,tokenizer=A__)

												# top_k=2, ntargets=3
												lowercase					=		sorted(vocab.keys())[:3]
												lowercase					=		fill_masker(f'This is a {tokenizer.mask_token}'     ,top_k=2     ,targets=A__)

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




							def 				A__   (       self     ,A__     ,A__):
												lowercase					=		FillMaskPipeline(model=A__     ,tokenizer=A__)
												lowercase					=		tokenizer.get_vocab()
												# String duplicates + id duplicates
												lowercase					=		sorted(vocab.keys())[:3]
												lowercase					=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
												lowercase					=		fill_masker(f'My name is {tokenizer.mask_token}'     ,targets=A__     ,top_k=1_0)

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





							def 				A__   (       self     ,A__     ,A__):
												lowercase					=		FillMaskPipeline(model=A__     ,tokenizer=A__)

												lowercase					=		fill_masker(
												    f'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'     ,top_k=2)
												self.assertEqual(
												    A__     ,[
												        [
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        ],
												        [
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        ],
												        [
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												            {'''sequence''': ANY(A__), '''score''': ANY(A__), '''token''': ANY(A__), '''token_str''': ANY(A__)},
												        ],
												    ]     ,)






from __future__ import annotations



def  UpperCamelCase					(							lowerCAmelCase__	):
					'''simple docstring'''
					if len(lowerCAmelCase__	) < 2:
										raise ValueError('''Monogons and Digons are not polygons in the Euclidean space'''	)
					if any(i <= 0 for i in nums	):
										raise ValueError('''All values must be greater than 0'''	)
					lowercase					=		nums.copy()
					copy_nums.sort()
					return copy_nums[-1] < sum(copy_nums[:-1]	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




