





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					:   int									=       MODEL_FOR_MASKED_LM_MAPPING
							__a					:   Dict									=       TF_MODEL_FOR_MASKED_LM_MAPPING

							def     UpperCAmelCase__	(							self							:     Tuple   )					->       Optional[Any]:







													"""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     UpperCAmelCase__	(							self							:     Dict   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      int     						=  pipeline(task='''fill-mask'''       ,     model='''sshleifer/tiny-distilroberta-base'''       ,     top_k=2       ,     framework='''tf'''   )
													UpperCAmelCase_			:      Dict     						=  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'''},
													    ]       ,     )

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

													UpperCAmelCase_			:      List[Any]     						=  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     UpperCAmelCase__	(							self							:     Optional[int]   )					->       List[str]:







													"""simple docstring"""
													UpperCAmelCase_			:      int     						=  pipeline(task='''fill-mask'''       ,     model='''sshleifer/tiny-distilroberta-base'''       ,     top_k=2       ,     framework='''pt'''   )

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

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

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

													UpperCAmelCase_			:      str     						=  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     UpperCAmelCase__	(							self							:     Dict   )					->       Union[str, Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  pipeline('''fill-mask'''       ,     model='''hf-internal-testing/tiny-random-distilbert'''       ,     device=0       ,     framework='''pt'''   )

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

													UpperCAmelCase_			:      Any     						=  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     UpperCAmelCase__	(							self							:     str   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      Tuple     						=  pipeline(task='''fill-mask'''       ,     model='''distilroberta-base'''       ,     top_k=2       ,     framework='''pt'''   )
													self.run_large_test(lowercase__   )

							@slow
							@require_tf
							def     UpperCAmelCase__	(							self							:     Dict   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  pipeline(task='''fill-mask'''       ,     model='''distilroberta-base'''       ,     top_k=2       ,     framework='''tf'''   )
													self.run_large_test(lowercase__   )

							def     UpperCAmelCase__	(							self							:     List[Any]       ,     __magic_name__							:     int   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      Dict     						=  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'''},
													    ]       ,     )
													UpperCAmelCase_			:      Optional[int]     						=  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''',
													        },
													    ]       ,     )

													UpperCAmelCase_			:      Dict     						=  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     UpperCAmelCase__	(							self							:     str   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      Tuple     						=  pipeline(task='''fill-mask'''       ,     model='''sshleifer/tiny-distilroberta-base'''       ,     framework='''pt'''   )
													UpperCAmelCase_			:      Optional[Any]     						=  None
													UpperCAmelCase_			:      Optional[Any]     						=  None
													self.run_pipeline_test(lowercase__       ,     []   )

							@require_tf
							def     UpperCAmelCase__	(							self							:     Any   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[str]     						=  pipeline(task='''fill-mask'''       ,     model='''sshleifer/tiny-distilroberta-base'''       ,     framework='''tf'''   )
													UpperCAmelCase_			:      str     						=  None
													UpperCAmelCase_			:      str     						=  None
													self.run_pipeline_test(lowercase__       ,     []   )

							def     UpperCAmelCase__	(							self							:     Dict       ,     __magic_name__							:     Tuple       ,     __magic_name__							:     int       ,     __magic_name__							:     Dict   )					->       Dict:







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

													UpperCAmelCase_			:      Dict     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )
													UpperCAmelCase_			:      Tuple     						=  [
													    F"""This is another {tokenizer.mask_token} test""",
													]
													return fill_masker, examples

							def     UpperCAmelCase__	(							self							:     List[Any]       ,     __magic_name__							:     List[Any]       ,     __magic_name__							:     Dict   )					->       Tuple:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[int]     						=  fill_masker.tokenizer
													UpperCAmelCase_			:      Optional[int]     						=  fill_masker.model

													UpperCAmelCase_			:      Any     						=  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__   )},
													    ]       ,     )

													UpperCAmelCase_			:      Union[str, Any]     						=  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__   )},
													    ]       ,     )

													UpperCAmelCase_			:      List[Any]     						=  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     UpperCAmelCase__	(							self							:     Tuple       ,     __magic_name__							:     Dict       ,     __magic_name__							:     Dict   )					->       Any:







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

													# Call argument
													UpperCAmelCase_			:      Optional[Any]     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )
													UpperCAmelCase_			:      List[str]     						=  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__   )},
													    ]       ,     )
													UpperCAmelCase_			:      Tuple     						=  {vocab[el] for el in targets}
													self.assertEqual({el['''token'''] for el in outputs}       ,     lowercase__   )
													UpperCAmelCase_			:      Dict     						=  [tokenizer.decode([x]   ) for x in target_ids]
													self.assertEqual({el['''token_str'''] for el in outputs}       ,     set(lowercase__   )   )

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

													# Raises with invalid
													with self.assertRaises(lowercase__   ):
																			UpperCAmelCase_			:      Optional[Any]     						=  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__   ):
																									UpperCAmelCase_			:      Union[str, Any]     						=  fill_masker(F"""This is a {tokenizer.mask_token}"""       ,     targets=['''''']   )
																			with self.assertRaises(lowercase__   ):
																									UpperCAmelCase_			:      str     						=  fill_masker(F"""This is a {tokenizer.mask_token}"""       ,     targets=''''''   )

							def     UpperCAmelCase__	(							self							:     Optional[Any]       ,     __magic_name__							:     int       ,     __magic_name__							:     Optional[int]   )					->       List[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[str]     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__       ,     top_k=2   )
													UpperCAmelCase_			:      Optional[Any]     						=  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__   )},
													    ]       ,     )

													UpperCAmelCase_			:      Optional[Any]     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )
													UpperCAmelCase_			:      Dict     						=  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     UpperCAmelCase__	(							self							:     int       ,     __magic_name__							:     List[str]       ,     __magic_name__							:     Optional[int]   )					->       List[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[str]     						=  tokenizer.get_vocab()
													UpperCAmelCase_			:      int     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )

													# top_k=2, ntargets=3
													UpperCAmelCase_			:      Optional[int]     						=  sorted(vocab.keys()   )[:3]
													UpperCAmelCase_			:      Dict     						=  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
													UpperCAmelCase_			:      Any     						=  [el["""token_str"""] for el in sorted(lowercase__       ,     key=lambda __magic_name__   : 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__   ):
																			UpperCAmelCase_			:      Any     						=  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     UpperCAmelCase__	(							self							:     Dict       ,     __magic_name__							:     List[str]       ,     __magic_name__							:     Dict   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[str]     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )
													UpperCAmelCase_			:      Optional[Any]     						=  tokenizer.get_vocab()
													# String duplicates + id duplicates
													UpperCAmelCase_			:      str     						=  sorted(vocab.keys()   )[:3]
													UpperCAmelCase_			:      int     						=  [targets[0], targets[1], targets[0], targets[2], targets[1]]
													UpperCAmelCase_			:      Any     						=  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     UpperCAmelCase__	(							self							:     Any       ,     __magic_name__							:     int       ,     __magic_name__							:     str   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  FillMaskPipeline(model=lowercase__       ,     tokenizer=lowercase__   )

													UpperCAmelCase_			:      List[str]     						=  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        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			list[int]   ) ->	list[list[int]]:
						UpperCAmelCase_			:      int     						=  []
						if len(SCREAMING_SNAKE_CASE__   ) == 1:
												return [nums.copy()]
						for _ in range(len(SCREAMING_SNAKE_CASE__   )   ):
												UpperCAmelCase_			:      List[Any]     						=  nums.pop(0   )
												UpperCAmelCase_			:      Optional[Any]     						=  permute(SCREAMING_SNAKE_CASE__   )
												for perm in permutations:
																		perm.append(SCREAMING_SNAKE_CASE__   )
												result.extend(SCREAMING_SNAKE_CASE__   )
												nums.append(SCREAMING_SNAKE_CASE__   )
						return result





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			List[str]   ) ->	Any:

						def backtrack(SCREAMING_SNAKE_CASE__      :			Union[str, Any]   ):
												if start == len(SCREAMING_SNAKE_CASE__   ) - 1:
																		output.append(nums[:]   )
												else:
																		for i in range(SCREAMING_SNAKE_CASE__,			len(SCREAMING_SNAKE_CASE__   )   ):
																								UpperCAmelCase_						,       UpperCAmelCase_			:      Tuple     						=  nums[i], nums[start]
																								backtrack(start + 1   )
																								UpperCAmelCase_						,       UpperCAmelCase_			:      int     						=  nums[i], nums[start]  # backtrack

						UpperCAmelCase_			:      Optional[int]     						=  []
						backtrack(0   )
						return output


if __name__ == "__main__":
					import doctest

					# use res to print the data in permute2 function
					snake_case_     :       Tuple						=  permutea([1, 2, 3])
					print(res)
					doctest.testmod()





