
"""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):
		A_						:       List[str]				   =	MODEL_FOR_MASKED_LM_MAPPING
		A_						:       Union[str, Any]				   =	TF_MODEL_FOR_MASKED_LM_MAPPING

		def 							__lowerCamelCase							(      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 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						List[str]									=      pipeline(task='fill-mask'       ,		model='sshleifer/tiny-distilroberta-base'       ,		top_k=2       ,		framework='tf' )
			__lowerCAmelCase			:						int									=      unmasker('My name is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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			:						Dict									=      unmasker('The largest city in France is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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			:						Optional[Any]									=      unmasker('My name is <mask>'       ,		targets=[' Patrick', ' Clara', ' Teven']       ,		top_k=3 )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						Any									=      pipeline(task='fill-mask'       ,		model='sshleifer/tiny-distilroberta-base'       ,		top_k=2       ,		framework='pt' )

			__lowerCAmelCase			:						List[Any]									=      unmasker('My name is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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			:						int									=      unmasker('The largest city in France is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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			:						Union[str, Any]									=      unmasker('My name is <mask>'       ,		targets=[' Patrick', ' Clara', ' Teven']       ,		top_k=3 )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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			:						str									=      unmasker('My name is <mask> <mask>'       ,		top_k=2 )

			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE       ,		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 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						Tuple									=      pipeline('fill-mask'       ,		model='hf-internal-testing/tiny-random-distilbert'       ,		device=0       ,		framework='pt' )

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

			__lowerCAmelCase			:						Optional[int]									=      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(_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE )

		@slow
		@require_torch
		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						Optional[Any]									=      pipeline(task='fill-mask'       ,		model='distilroberta-base'       ,		top_k=2       ,		framework='pt' )
			self.run_large_test(_SCREAMING_SNAKE_CASE )

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

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE ):
			__lowerCAmelCase			:						Any									=      unmasker('My name is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE )       ,		[
			        {'sequence': 'My name is John', 'score': 0.008, 'token': 6_10, 'token_str': ' John'},
			        {'sequence': 'My name is Chris', 'score': 0.007, 'token': 15_73, 'token_str': ' Chris'},
			    ]       ,		)
			__lowerCAmelCase			:						Optional[int]									=      unmasker('The largest city in France is <mask>' )
			self.assertEqual(
			    nested_simplify(_SCREAMING_SNAKE_CASE )       ,		[
			        {
			            'sequence': 'The largest city in France is Paris',
			            'score': 0.251,
			            'token': 22_01,
			            'token_str': ' Paris',
			        },
			        {
			            'sequence': 'The largest city in France is Lyon',
			            'score': 0.214,
			            'token': 1_27_90,
			            'token_str': ' Lyon',
			        },
			    ]       ,		)

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

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

		@require_tf
		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						List[Any]									=      pipeline(task='fill-mask'       ,		model='sshleifer/tiny-distilroberta-base'       ,		framework='tf' )
			__lowerCAmelCase			:						str									=      None
			__lowerCAmelCase			:						Union[str, Any]									=      None
			self.run_pipeline_test(_SCREAMING_SNAKE_CASE       ,		[] )

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE ):
			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			:						List[str]									=      FillMaskPipeline(model=_SCREAMING_SNAKE_CASE       ,		tokenizer=_SCREAMING_SNAKE_CASE )
			__lowerCAmelCase			:						str									=      [
			    f"This is another {tokenizer.mask_token} test",
			]
			return fill_masker, examples

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE ):
			__lowerCAmelCase			:						List[Any]									=      fill_masker.tokenizer
			__lowerCAmelCase			:						str									=      fill_masker.model

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

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

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

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

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

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

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

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

			# Raises with invalid
			with self.assertRaises(_SCREAMING_SNAKE_CASE ):
				__lowerCAmelCase			:						List[str]									=      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(_SCREAMING_SNAKE_CASE ):
					__lowerCAmelCase			:						Optional[Any]									=      fill_masker(f"This is a {tokenizer.mask_token}"       ,		targets=[''] )
				with self.assertRaises(_SCREAMING_SNAKE_CASE ):
					__lowerCAmelCase			:						Tuple									=      fill_masker(f"This is a {tokenizer.mask_token}"       ,		targets='' )

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE ):
			__lowerCAmelCase			:						Optional[Any]									=      FillMaskPipeline(model=_SCREAMING_SNAKE_CASE       ,		tokenizer=_SCREAMING_SNAKE_CASE       ,		top_k=2 )
			__lowerCAmelCase			:						str									=      fill_masker(f"This is a {tokenizer.mask_token}" )
			self.assertEqual(
			    _SCREAMING_SNAKE_CASE       ,		[
			        {'sequence': ANY(_SCREAMING_SNAKE_CASE ), 'score': ANY(_SCREAMING_SNAKE_CASE ), 'token': ANY(_SCREAMING_SNAKE_CASE ), 'token_str': ANY(_SCREAMING_SNAKE_CASE )},
			        {'sequence': ANY(_SCREAMING_SNAKE_CASE ), 'score': ANY(_SCREAMING_SNAKE_CASE ), 'token': ANY(_SCREAMING_SNAKE_CASE ), 'token_str': ANY(_SCREAMING_SNAKE_CASE )},
			    ]       ,		)

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

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE ):
			__lowerCAmelCase			:						List[str]									=      tokenizer.get_vocab()
			__lowerCAmelCase			:						Optional[int]									=      FillMaskPipeline(model=_SCREAMING_SNAKE_CASE       ,		tokenizer=_SCREAMING_SNAKE_CASE )

			# top_k=2, ntargets=3
			__lowerCAmelCase			:						Union[str, Any]									=      sorted(vocab.keys() )[:3]
			__lowerCAmelCase			:						str									=      fill_masker(f"This is a {tokenizer.mask_token}"       ,		top_k=2       ,		targets=_SCREAMING_SNAKE_CASE )

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

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

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







		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE ):
			__lowerCAmelCase			:						List[str]									=      FillMaskPipeline(model=_SCREAMING_SNAKE_CASE       ,		tokenizer=_SCREAMING_SNAKE_CASE )

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



'''simple docstring'''







from __future__ import annotations

import requests


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	str  )  ->			dict:
       _a    : Any     					=F"https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty"
       return requests.get(_UpperCAmelCase  ).json()


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int = 10  )  ->			list[dict]:
       _a    : Union[str, Any]     					="""https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty"""
       _a    : int     					=requests.get(_UpperCAmelCase  ).json()[:max_stories]
       return [get_hackernews_story(_UpperCAmelCase  ) for story_id in story_ids]


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int = 10  )  ->			str:
       _a    : Union[str, Any]     					=hackernews_top_stories(_UpperCAmelCase  )
       return "\n".join("""* [{title}]({url})""".format(**_UpperCAmelCase  ) for story in stories  )


if __name__ == "__main__":
   print(hackernews_top_stories_as_markdown())


