
"""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        _UpperCAmelCase(       unittest.TestCase      ):
		lowercase__         = MODEL_FOR_MASKED_LM_MAPPING
		lowercase__         = TF_MODEL_FOR_MASKED_LM_MAPPING



		def 		UpperCAmelCase				(   self)			->			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)			->			List[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    pipeline(task='''fill-mask'''							,						model='''sshleifer/tiny-distilroberta-base'''							,						top_k=2							,						framework='''tf''')
							_UpperCamelCase									=    unmasker('''My name is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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									=    unmasker('''The largest city in France is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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									=    unmasker('''My name is <mask>'''							,						targets=[''' Patrick''', ''' Clara''', ''' Teven''']							,						top_k=3)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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)			->			Any:






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

							_UpperCamelCase									=    unmasker('''My name is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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									=    unmasker('''The largest city in France is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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									=    unmasker('''My name is <mask>'''							,						targets=[''' Patrick''', ''' Clara''', ''' Teven''']							,						top_k=3)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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									=    unmasker('''My name is <mask> <mask>'''							,						top_k=2)

							self.assertEqual(
							    nested_simplify(lowerCAmelCase__							,						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)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    pipeline('''fill-mask'''							,						model='''hf-internal-testing/tiny-random-distilbert'''							,						device=0							,						framework='''pt''')

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

							_UpperCamelCase									=    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(lowerCAmelCase__							,						lowerCAmelCase__)



		@slow
		@require_torch
		def 		UpperCAmelCase				(   self)			->			List[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    pipeline(task='''fill-mask'''							,						model='''distilroberta-base'''							,						top_k=2							,						framework='''pt''')
							self.run_large_test(lowerCAmelCase__)



		@slow
		@require_tf
		def 		UpperCAmelCase				(   self)			->			str:






							'''simple docstring'''
							_UpperCamelCase									=    pipeline(task='''fill-mask'''							,						model='''distilroberta-base'''							,						top_k=2							,						framework='''tf''')
							self.run_large_test(lowerCAmelCase__)



		def 		UpperCAmelCase				(   self							,						__a)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    unmasker('''My name is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__)							,						[
							        {'''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'''},
							    ]							,						)
							_UpperCamelCase									=    unmasker('''The largest city in France is <mask>''')
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__)							,						[
							        {
							            '''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''',
							        },
							    ]							,						)

							_UpperCamelCase									=    unmasker('''My name is <mask>'''							,						targets=[''' Patrick''', ''' Clara''', ''' Teven''']							,						top_k=3)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__)							,						[
							        {'''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 		UpperCAmelCase				(   self)			->			Optional[Any]:






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



		@require_tf
		def 		UpperCAmelCase				(   self)			->			Optional[int]:






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



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a)			->			int:






							'''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									=    FillMaskPipeline(model=lowerCAmelCase__							,						tokenizer=lowerCAmelCase__)
							_UpperCamelCase									=    [
							    F'''This is another {tokenizer.mask_token} test''',
							]
							return fill_masker, examples



		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    fill_masker.tokenizer
							_UpperCamelCase									=    fill_masker.model

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

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

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

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

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



		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			str:






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

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

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

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



		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    FillMaskPipeline(model=lowerCAmelCase__							,						tokenizer=lowerCAmelCase__							,						top_k=2)
							_UpperCamelCase									=    fill_masker(F'''This is a {tokenizer.mask_token}''')
							self.assertEqual(
							    lowerCAmelCase__							,						[
							        {'''sequence''': ANY(lowerCAmelCase__), '''score''': ANY(lowerCAmelCase__), '''token''': ANY(lowerCAmelCase__), '''token_str''': ANY(lowerCAmelCase__)},
							        {'''sequence''': ANY(lowerCAmelCase__), '''score''': ANY(lowerCAmelCase__), '''token''': ANY(lowerCAmelCase__), '''token_str''': ANY(lowerCAmelCase__)},
							    ]							,						)

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



		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    tokenizer.get_vocab()
							_UpperCamelCase									=    FillMaskPipeline(model=lowerCAmelCase__							,						tokenizer=lowerCAmelCase__)

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

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



		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    FillMaskPipeline(model=lowerCAmelCase__							,						tokenizer=lowerCAmelCase__)
							_UpperCamelCase									=    tokenizer.get_vocab()
							# String duplicates + id duplicates
							_UpperCamelCase									=    sorted(vocab.keys())[:3]
							_UpperCamelCase									=    [targets[0], targets[1], targets[0], targets[2], targets[1]]
							_UpperCamelCase									=    fill_masker(F'''My name is {tokenizer.mask_token}'''							,						targets=lowerCAmelCase__							,						top_k=10)

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




		def 		UpperCAmelCase				(   self							,						__a							,						__a)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    FillMaskPipeline(model=lowerCAmelCase__							,						tokenizer=lowerCAmelCase__)

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











'''simple docstring'''



from math import pow
def        UpperCAmelCase (    A	:					int       ,		A	:					int       ,		A	:					int       ,		A	:					int       ,		A	:					int       ,		):
							if current_sum == needed_sum:
														# If the sum of the powers is equal to needed_sum, then we have a solution.
														solutions_count += 1
														return current_sum, solutions_count

							SCREAMING_SNAKE_CASE       :   Tuple         =      int(pow(A       ,		A					)					)
							if current_sum + i_to_n <= needed_sum:
														# If the sum of the powers is less than needed_sum, then continue adding powers.
														current_sum += i_to_n
														SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Dict         =      backtrack(
														    A       ,		A       ,		current_number + 1       ,		A       ,		A					)
														current_sum -= i_to_n
							if i_to_n < needed_sum:
														# If the power of i is less than needed_sum, then try with the next power.
														SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   int         =      backtrack(
														    A       ,		A       ,		current_number + 1       ,		A       ,		A					)
							return current_sum, solutions_count
def        UpperCAmelCase (    A	:					int       ,		A	:					int					):
							if not (1 <= needed_sum <= 1000 and 2 <= power <= 10):
														raise ValueError(
														    '''Invalid input\n'''
														    '''needed_sum must be between 1 and 1000, power between 2 and 10.'''					)

							return backtrack(A       ,		A       ,		1       ,		0       ,		0					)[1]  # Return the solutions_count


if __name__ == "__main__":
							import doctest

							doctest.testmod()




