





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'''







			lowerCAmelCase_							  =		MODEL_FOR_MASKED_LM_MAPPING
			lowerCAmelCase_							  =		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'''







				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(UpperCAmelCase__ ,						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'''},
				    ] ,						)

				lowerCamelCase__              =	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''': 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''',
				        },
				    ] ,						)

				lowerCamelCase__              =	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''': 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 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				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(UpperCAmelCase__ ,						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'''},
				    ] ,						)

				lowerCamelCase__              =	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''': 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'''},
				    ] ,						)

				lowerCamelCase__              =	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''': 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'''},
				    ] ,						)

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

				self.assertEqual(
				    nested_simplify(UpperCAmelCase__ ,						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 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				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(UpperCAmelCase__ ,						UpperCAmelCase__							)





			@slow
			@require_torch
			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	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'''







				lowerCamelCase__              =	pipeline(task='''fill-mask''' ,						model='''distilroberta-base''' ,						top_k=2 ,						framework='''tf'''							)
				self.run_large_test(UpperCAmelCase__							)





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	unmasker('''My name is <mask>'''							)
				self.assertEqual(
				    nested_simplify(UpperCAmelCase__							) ,						[
				        {'''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'''},
				    ] ,						)
				lowerCamelCase__              =	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''': 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''',
				        },
				    ] ,						)

				lowerCamelCase__              =	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''': 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 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline(task='''fill-mask''' ,						model='''sshleifer/tiny-distilroberta-base''' ,						framework='''pt'''							)
				lowerCamelCase__              =	None
				lowerCamelCase__              =	None
				self.run_pipeline_test(UpperCAmelCase__ ,						[]							)





			@require_tf
			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline(task='''fill-mask''' ,						model='''sshleifer/tiny-distilroberta-base''' ,						framework='''tf'''							)
				lowerCamelCase__              =	None
				lowerCamelCase__              =	None
				self.run_pipeline_test(UpperCAmelCase__ ,						[]							)





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''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)'''							)

				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)
				lowerCamelCase__              =	[
				    F'This is another {tokenizer.mask_token} test',
				]
				return fill_masker, examples





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	fill_masker.tokenizer
				lowerCamelCase__              =	fill_masker.model

				lowerCamelCase__              =	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__							)},
				    ] ,						)

				lowerCamelCase__              =	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__							)},
				    ] ,						)

				lowerCamelCase__              =	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 ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	tokenizer.get_vocab()
				lowerCamelCase__              =	sorted(vocab.keys()							)[:2]
				# Pipeline argument
				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__ ,						targets=UpperCAmelCase__							)
				lowerCamelCase__              =	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__							)},
				    ] ,						)
				lowerCamelCase__              =	{vocab[el] for el in targets}
				self.assertEqual({el['''token'''] for el in outputs} ,						UpperCAmelCase__							)
				lowerCamelCase__              =	[tokenizer.decode([x]							) for x in target_ids]
				self.assertEqual({el['''token_str'''] for el in outputs} ,						set(UpperCAmelCase__							)							)

				# Call argument
				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)
				lowerCamelCase__              =	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__							)},
				    ] ,						)
				lowerCamelCase__              =	{vocab[el] for el in targets}
				self.assertEqual({el['''token'''] for el in outputs} ,						UpperCAmelCase__							)
				lowerCamelCase__              =	[tokenizer.decode([x]							) for x in target_ids]
				self.assertEqual({el['''token_str'''] for el in outputs} ,						set(UpperCAmelCase__							)							)

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

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





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__ ,						top_k=2							)
				lowerCamelCase__              =	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__							)},
				    ] ,						)

				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)
				lowerCamelCase__              =	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 ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	tokenizer.get_vocab()
				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)

				# top_k=2, ntargets=3
				lowerCamelCase__              =	sorted(vocab.keys()							)[:3]
				lowerCamelCase__              =	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
				lowerCamelCase__              =	[el['''token_str'''] for el in sorted(UpperCAmelCase__ ,						key=lambda __lowerCAmelCase							: 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__							):
					lowerCamelCase__              =	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 ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)
				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=UpperCAmelCase__ ,						top_k=1_0							)

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





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	FillMaskPipeline(model=UpperCAmelCase__ ,						tokenizer=UpperCAmelCase__							)

				lowerCamelCase__              =	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__							)},
				        ],
				    ] ,						)










from queue import PriorityQueue
from typing import Any

import numpy as np





def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,)       ->   float | int:







	'''simple docstring'''







	for nxt, d in graph[v]:
		if nxt in visited_forward:
			continue
		lowerCamelCase__              =	cst_fwd.get(__snake_case ,np.inf							)
		lowerCamelCase__              =	cst_fwd[v] + d
		if new_cost_f < old_cost_f:
			queue.put((new_cost_f, nxt)							)
			lowerCamelCase__              =	new_cost_f
			lowerCamelCase__              =	v
		if nxt in visited_backward:
			if cst_fwd[v] + d + cst_bwd[nxt] < shortest_distance:
				lowerCamelCase__              =	cst_fwd[v] + d + cst_bwd[nxt]
	return shortest_distance





def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,__snake_case							)       ->   int:







	'''simple docstring'''







	lowerCamelCase__              =	-1

	lowerCamelCase__              =	set()
	lowerCamelCase__              =	set()
	lowerCamelCase__              =	{source: 0}
	lowerCamelCase__              =	{destination: 0}
	lowerCamelCase__              =	{source: None}
	lowerCamelCase__              =	{destination: None}
	lowerCamelCase__              =	PriorityQueue()
	lowerCamelCase__              =	PriorityQueue()

	lowerCamelCase__              =	np.inf

	queue_forward.put((0, source)							)
	queue_backward.put((0, destination)							)

	if source == destination:
		return 0

	while not queue_forward.empty() and not queue_backward.empty():
		lowerCamelCase__       ,			lowerCamelCase__              =	queue_forward.get()
		visited_forward.add(__snake_case							)

		lowerCamelCase__       ,			lowerCamelCase__              =	queue_backward.get()
		visited_backward.add(__snake_case							)

		lowerCamelCase__              =	pass_and_relaxation(
		    __snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,)

		lowerCamelCase__              =	pass_and_relaxation(
		    __snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,__snake_case ,)

		if cst_fwd[v_fwd] + cst_bwd[v_bwd] >= shortest_distance:
			break

	if shortest_distance != np.inf:
		lowerCamelCase__              =	shortest_distance
	return shortest_path_distance


_a						=   {
    "B": [["C", 1]],
    "C": [["D", 1]],
    "D": [["F", 1]],
    "E": [["B", 1], ["G", 2]],
    "F": [],
    "G": [["F", 1]],
}
_a						=   {
    "B": [["E", 1]],
    "C": [["B", 1]],
    "D": [["C", 1]],
    "F": [["D", 1], ["G", 1]],
    "E": [[None, np.inf]],
    "G": [["E", 2]],
}

if __name__ == "__main__":
			import doctest

			doctest.testmod()



