




"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a  =				{
    '''configuration_timesformer''': ['''TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TimesformerConfig'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a  =				[
		    '''TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TimesformerModel''',
		    '''TimesformerForVideoClassification''',
		    '''TimesformerPreTrainedModel''',
		]

if TYPE_CHECKING:
		from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_timesformer import (
				    TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TimesformerForVideoClassification,
				    TimesformerModel,
				    TimesformerPreTrainedModel,
				)

else:
		import sys

		a  =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)












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






							def        __a  (  self )      ->					Tuple:
								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								if is_torch_available():
									import torch

									torch.cuda.empty_cache()






							@require_tf
							def        __a  (  self )      ->					List[Any]:
								a :						Dict      =							pipeline(task="fill-mask" ,   model="sshleifer/tiny-distilroberta-base" ,   top_k=2 ,   framework="tf" )
								a :						Optional[Any]      =							unmasker("My name is <mask>" )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {"sequence": "My name is grouped", "score": 2.1E-05, "token": 3_8015, "token_str": " grouped"},
								        {"sequence": "My name is accuser", "score": 2.1E-05, "token": 2_5506, "token_str": " accuser"},
								    ] ,   )

								a :						str      =							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_8015,
								            "token_str": " grouped",
								        },
								        {
								            "sequence": "The largest city in France is accuser",
								            "score": 2.1E-05,
								            "token": 2_5506,
								            "token_str": " accuser",
								        },
								    ] ,   )

								a :						Any      =							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_3606, "token_str": " Clara"},
								        {"sequence": "My name is Patrick", "score": 2E-05, "token": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Te", "score": 1.9E-05, "token": 2941, "token_str": " Te"},
								    ] ,   )






							@require_torch
							def        __a  (  self )      ->					Tuple:
								a :						Optional[int]      =							pipeline(task="fill-mask" ,   model="sshleifer/tiny-distilroberta-base" ,   top_k=2 ,   framework="pt" )

								a :						int      =							unmasker("My name is <mask>" )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {"sequence": "My name is Maul", "score": 2.2E-05, "token": 3_5676, "token_str": " Maul"},
								        {"sequence": "My name isELS", "score": 2.2E-05, "token": 1_6416, "token_str": "ELS"},
								    ] ,   )

								a :						Optional[Any]      =							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_5676,
								            "token_str": " Maul",
								        },
								        {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 1_6416, "token_str": "ELS"},
								    ] ,   )

								a :						List[str]      =							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": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Te", "score": 2E-05, "token": 2941, "token_str": " Te"},
								        {"sequence": "My name is Clara", "score": 2E-05, "token": 1_3606, "token_str": " Clara"},
								    ] ,   )

								a :						Optional[int]      =							unmasker("My name is <mask> <mask>" ,   top_k=2 )

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






							@require_torch_gpu
							def        __a  (  self )      ->					Optional[Any]:
								a :						List[Any]      =							pipeline("fill-mask" ,   model="hf-internal-testing/tiny-random-distilbert" ,   device=0 ,   framework="pt" )

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

								a :						Optional[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(lowerCAmelCase__ ,   lowerCAmelCase__ )






							@slow
							@require_torch
							def        __a  (  self )      ->					Any:
								a :						List[Any]      =							pipeline(task="fill-mask" ,   model="distilroberta-base" ,   top_k=2 ,   framework="pt" )
								self.run_large_test(lowerCAmelCase__ )






							@slow
							@require_tf
							def        __a  (  self )      ->					Any:
								a :						int      =							pipeline(task="fill-mask" ,   model="distilroberta-base" ,   top_k=2 ,   framework="tf" )
								self.run_large_test(lowerCAmelCase__ )






							def        __a  (  self ,   lowerCAmelCase__ )      ->					List[Any]:
								a :						List[str]      =							unmasker("My name is <mask>" )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ) ,   [
								        {"sequence": "My name is John", "score": 0.008, "token": 610, "token_str": " John"},
								        {"sequence": "My name is Chris", "score": 0.007, "token": 1573, "token_str": " Chris"},
								    ] ,   )
								a :						Union[str, Any]      =							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": 2201,
								            "token_str": " Paris",
								        },
								        {
								            "sequence": "The largest city in France is Lyon",
								            "score": 0.214,
								            "token": 1_2790,
								            "token_str": " Lyon",
								        },
								    ] ,   )

								a :						Tuple      =							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": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Clara", "score": 0.000, "token": 1_3606, "token_str": " Clara"},
								        {"sequence": "My name is Te", "score": 0.000, "token": 2941, "token_str": " Te"},
								    ] ,   )






							@require_torch
							def        __a  (  self )      ->					str:
								a :						Any      =							pipeline(task="fill-mask" ,   model="sshleifer/tiny-distilroberta-base" ,   framework="pt" )
								a :						List[str]      =							None
								a :						Dict      =							None
								self.run_pipeline_test(lowerCAmelCase__ ,   [] )






							@require_tf
							def        __a  (  self )      ->					str:
								a :						Optional[Any]      =							pipeline(task="fill-mask" ,   model="sshleifer/tiny-distilroberta-base" ,   framework="tf" )
								a :						Any      =							None
								a :						Optional[int]      =							None
								self.run_pipeline_test(lowerCAmelCase__ ,   [] )






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Tuple:
								if tokenizer is None or tokenizer.mask_token_id is None:
									self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)" )

								a :						str      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								a :						Optional[Any]      =							[
								    f"""This is another {tokenizer.mask_token} test""",
								]
								return fill_masker, examples






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					str:
								a :						Any      =							fill_masker.tokenizer
								a :						Optional[int]      =							fill_masker.model

								a :						List[str]      =							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__ )},
								    ] ,   )

								a :						int      =							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__ )},
								    ] ,   )

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

								# Call argument
								a :						Optional[Any]      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								a :						int      =							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__ )},
								    ] ,   )
								a :						Any      =							{vocab[el] for el in targets}
								self.assertEqual({el["token"] for el in outputs} ,   lowerCAmelCase__ )
								a :						Optional[Any]      =							[tokenizer.decode([x] ) for x in target_ids]
								self.assertEqual({el["token_str"] for el in outputs} ,   set(lowerCAmelCase__ ) )

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

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






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[Any]:
								a :						int      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ ,   top_k=2 )
								a :						List[Any]      =							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__ )},
								    ] ,   )

								a :						Optional[Any]      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								a :						Optional[int]      =							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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					str:
								a :						Tuple      =							tokenizer.get_vocab()
								a :						List[str]      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )

								# top_k=2, ntargets=3
								a :						Tuple      =							sorted(vocab.keys() )[:3]
								a :						Tuple      =							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
								a :						str      =							[el["token_str"] for el in sorted(lowerCAmelCase__ ,   key=lambda lowerCAmelCase__ : 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__ ):
									a :						Optional[int]      =							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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Any:
								a :						Tuple      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								a :						Union[str, Any]      =							tokenizer.get_vocab()
								# String duplicates + id duplicates
								a :						Optional[Any]      =							sorted(vocab.keys() )[:3]
								a :						int      =							[targets[0], targets[1], targets[0], targets[2], targets[1]]
								a :						Tuple      =							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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[int]:
								a :						str      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )

								a :						Dict      =							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__ )},
								        ],
								    ] ,   )


