
"""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 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  int						   =		MODEL_FOR_MASKED_LM_MAPPING
		__lowercase							:  Optional[int]						   =		TF_MODEL_FOR_MASKED_LM_MAPPING




		def 	snake_case_     (     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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""sshleifer/tiny-distilroberta-base"""							,  top_k=2							,  framework="""tf""")
				__SCREAMING_SNAKE_CASE            = unmasker("""My name is <mask>""")
				self.assertEqual(
				    nested_simplify(lowerCAmelCase__							,  decimals=6)							,  [
				        {"""sequence""": """My name is grouped""", """score""": 2.1E-05, """token""": 3_8_0_1_5, """token_str""": """ grouped"""},
				        {"""sequence""": """My name is accuser""", """score""": 2.1E-05, """token""": 2_5_5_0_6, """token_str""": """ accuser"""},
				    ]							,  )

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

				__SCREAMING_SNAKE_CASE            = 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_3_6_0_6, """token_str""": """ Clara"""},
				        {"""sequence""": """My name is Patrick""", """score""": 2E-05, """token""": 3_4_9_9, """token_str""": """ Patrick"""},
				        {"""sequence""": """My name is Te""", """score""": 1.9E-05, """token""": 2_9_4_1, """token_str""": """ Te"""},
				    ]							,  )




		@require_torch
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""sshleifer/tiny-distilroberta-base"""							,  top_k=2							,  framework="""pt""")

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

				__SCREAMING_SNAKE_CASE            = 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_5_6_7_6,
				            """token_str""": """ Maul""",
				        },
				        {"""sequence""": """The largest city in France isELS""", """score""": 2.2E-05, """token""": 1_6_4_1_6, """token_str""": """ELS"""},
				    ]							,  )

				__SCREAMING_SNAKE_CASE            = 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""": 3_4_9_9, """token_str""": """ Patrick"""},
				        {"""sequence""": """My name is Te""", """score""": 2E-05, """token""": 2_9_4_1, """token_str""": """ Te"""},
				        {"""sequence""": """My name is Clara""", """score""": 2E-05, """token""": 1_3_6_0_6, """token_str""": """ Clara"""},
				    ]							,  )

				__SCREAMING_SNAKE_CASE            = unmasker("""My name is <mask> <mask>"""							,  top_k=2)

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




		@require_torch_gpu
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline("""fill-mask"""							,  model="""hf-internal-testing/tiny-random-distilbert"""							,  device=0							,  framework="""pt""")

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

				__SCREAMING_SNAKE_CASE            = 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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""distilroberta-base"""							,  top_k=2							,  framework="""pt""")
				self.run_large_test(lowerCAmelCase__)




		@slow
		@require_tf
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""distilroberta-base"""							,  top_k=2							,  framework="""tf""")
				self.run_large_test(lowerCAmelCase__)




		def 	snake_case_     (     self							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = unmasker("""My name is <mask>""")
				self.assertEqual(
				    nested_simplify(lowerCAmelCase__)							,  [
				        {"""sequence""": """My name is John""", """score""": 0.0_08, """token""": 6_1_0, """token_str""": """ John"""},
				        {"""sequence""": """My name is Chris""", """score""": 0.0_07, """token""": 1_5_7_3, """token_str""": """ Chris"""},
				    ]							,  )
				__SCREAMING_SNAKE_CASE            = unmasker("""The largest city in France is <mask>""")
				self.assertEqual(
				    nested_simplify(lowerCAmelCase__)							,  [
				        {
				            """sequence""": """The largest city in France is Paris""",
				            """score""": 0.2_51,
				            """token""": 2_2_0_1,
				            """token_str""": """ Paris""",
				        },
				        {
				            """sequence""": """The largest city in France is Lyon""",
				            """score""": 0.2_14,
				            """token""": 1_2_7_9_0,
				            """token_str""": """ Lyon""",
				        },
				    ]							,  )

				__SCREAMING_SNAKE_CASE            = unmasker("""My name is <mask>"""							,  targets=[""" Patrick""", """ Clara""", """ Teven"""]							,  top_k=3)
				self.assertEqual(
				    nested_simplify(lowerCAmelCase__)							,  [
				        {"""sequence""": """My name is Patrick""", """score""": 0.0_05, """token""": 3_4_9_9, """token_str""": """ Patrick"""},
				        {"""sequence""": """My name is Clara""", """score""": 0.0_00, """token""": 1_3_6_0_6, """token_str""": """ Clara"""},
				        {"""sequence""": """My name is Te""", """score""": 0.0_00, """token""": 2_9_4_1, """token_str""": """ Te"""},
				    ]							,  )




		@require_torch
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""sshleifer/tiny-distilroberta-base"""							,  framework="""pt""")
				__SCREAMING_SNAKE_CASE            = None
				__SCREAMING_SNAKE_CASE            = None
				self.run_pipeline_test(lowerCAmelCase__							,  [])




		@require_tf
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = pipeline(task="""fill-mask"""							,  model="""sshleifer/tiny-distilroberta-base"""							,  framework="""tf""")
				__SCREAMING_SNAKE_CASE            = None
				__SCREAMING_SNAKE_CASE            = None
				self.run_pipeline_test(lowerCAmelCase__							,  [])




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

				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = [
				    f"This is another {tokenizer.mask_token} test",
				]
				return fill_masker, examples




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = fill_masker.tokenizer
				__SCREAMING_SNAKE_CASE            = fill_masker.model

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

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

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

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

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

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




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__							,  top_k=2)
				__SCREAMING_SNAKE_CASE            = 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__)},
				    ]							,  )

				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = 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 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = tokenizer.get_vocab()
				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__)

				# top_k=2, ntargets=3
				__SCREAMING_SNAKE_CASE            = sorted(vocab.keys())[:3]
				__SCREAMING_SNAKE_CASE            = 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
				__SCREAMING_SNAKE_CASE            = [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__):
						__SCREAMING_SNAKE_CASE            = 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 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = tokenizer.get_vocab()
				# String duplicates + id duplicates
				__SCREAMING_SNAKE_CASE            = sorted(vocab.keys())[:3]
				__SCREAMING_SNAKE_CASE            = [targets[0], targets[1], targets[0], targets[2], targets[1]]
				__SCREAMING_SNAKE_CASE            = fill_masker(f"My name is {tokenizer.mask_token}"							,  targets=lowerCAmelCase__							,  top_k=1_0)

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




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = FillMaskPipeline(model=lowerCAmelCase__							,  tokenizer=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = 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 ..utils import DummyObject, requires_backends
class 						SCREAMING_SNAKE_CASE_ (						metaclass=__a ):




		"""simple docstring"""





		__lowercase							:  Tuple						   =		['''keras_nlp''']




		def __init__(     self							,  *lowerCAmelCase__							,  **lowerCAmelCase__):
				requires_backends(self							,  ["""keras_nlp"""])




