





import os
from typing import List, Optional, Union

from ...image_processing_utils import BatchFeature
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
from ..auto import AutoTokenizer

class        __SCREAMING_SNAKE_CASE					(     _a       ):
							snake_case     :      Any						     =       ["""image_processor""", """tokenizer"""]
							snake_case     :      Optional[int]						     =       """BlipImageProcessor"""
							snake_case     :      Optional[Any]						     =       """AutoTokenizer"""






							def __init__(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  ):
														super().__init__(__lowerCAmelCase  , __lowerCAmelCase  )

														# add QFormer tokenizer
														UpperCamelCase__				     =			qformer_tokenizer






							def __call__(						self  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = True  , __lowerCAmelCase = False  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = 0  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = False  , __lowerCAmelCase = False  , __lowerCAmelCase = False  , __lowerCAmelCase = False  , __lowerCAmelCase = False  , __lowerCAmelCase = True  , __lowerCAmelCase = None  , **__lowerCAmelCase  , ):
														if images is None and text is None:
																					raise ValueError("""You have to specify at least images or text."""  )

														UpperCamelCase__				     =			BatchFeature()

														if text is not None:
																					UpperCamelCase__				     =			self.tokenizer(
																					    text=__lowerCAmelCase  , add_special_tokens=__lowerCAmelCase  , padding=__lowerCAmelCase  , truncation=__lowerCAmelCase  , max_length=__lowerCAmelCase  , stride=__lowerCAmelCase  , pad_to_multiple_of=__lowerCAmelCase  , return_attention_mask=__lowerCAmelCase  , return_overflowing_tokens=__lowerCAmelCase  , return_special_tokens_mask=__lowerCAmelCase  , return_offsets_mapping=__lowerCAmelCase  , return_token_type_ids=__lowerCAmelCase  , return_length=__lowerCAmelCase  , verbose=__lowerCAmelCase  , return_tensors=__lowerCAmelCase  , **__lowerCAmelCase  , )
																					encoding.update(__lowerCAmelCase  )
																					UpperCamelCase__				     =			self.qformer_tokenizer(
																					    text=__lowerCAmelCase  , add_special_tokens=__lowerCAmelCase  , padding=__lowerCAmelCase  , truncation=__lowerCAmelCase  , max_length=__lowerCAmelCase  , stride=__lowerCAmelCase  , pad_to_multiple_of=__lowerCAmelCase  , return_attention_mask=__lowerCAmelCase  , return_overflowing_tokens=__lowerCAmelCase  , return_special_tokens_mask=__lowerCAmelCase  , return_offsets_mapping=__lowerCAmelCase  , return_token_type_ids=__lowerCAmelCase  , return_length=__lowerCAmelCase  , verbose=__lowerCAmelCase  , return_tensors=__lowerCAmelCase  , **__lowerCAmelCase  , )
																					UpperCamelCase__				     =			qformer_text_encoding.pop("""input_ids"""  )
																					UpperCamelCase__				     =			qformer_text_encoding.pop("""attention_mask"""  )

														if images is not None:
																					UpperCamelCase__				     =			self.image_processor(__lowerCAmelCase  , return_tensors=__lowerCAmelCase  )
																					encoding.update(__lowerCAmelCase  )

														return encoding






							def 				_lowerCamelCase		(						self  , *__lowerCAmelCase  , **__lowerCAmelCase  ):
														return self.tokenizer.batch_decode(*__lowerCAmelCase  , **__lowerCAmelCase  )






							def 				_lowerCamelCase		(						self  , *__lowerCAmelCase  , **__lowerCAmelCase  ):
														return self.tokenizer.decode(*__lowerCAmelCase  , **__lowerCAmelCase  )






							@property
							# Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
							def 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			self.tokenizer.model_input_names
														UpperCamelCase__				     =			self.image_processor.model_input_names
														return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names  )  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , **__lowerCAmelCase  ):
														if os.path.isfile(__lowerCAmelCase  ):
																					raise ValueError(f"""Provided path ({save_directory}) should be a directory, not a file"""  )
														os.makedirs(__lowerCAmelCase  , exist_ok=__lowerCAmelCase  )
														UpperCamelCase__				     =			os.path.join(__lowerCAmelCase  , """qformer_tokenizer"""  )
														self.qformer_tokenizer.save_pretrained(__lowerCAmelCase  )
														return super().save_pretrained(__lowerCAmelCase  , **__lowerCAmelCase  )







							@classmethod
							def 				_lowerCamelCase		(						cls  , __lowerCAmelCase  , **__lowerCAmelCase  ):
														UpperCamelCase__				     =			AutoTokenizer.from_pretrained(__lowerCAmelCase  , subfolder="""qformer_tokenizer"""  )
														UpperCamelCase__				     =			cls._get_arguments_from_pretrained(__lowerCAmelCase  , **__lowerCAmelCase  )
														args.append(__lowerCAmelCase  )
														return cls(*__lowerCAmelCase  )











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       ):
							snake_case     :      Any						     =       MODEL_FOR_MASKED_LM_MAPPING
							snake_case     :      Dict						     =       TF_MODEL_FOR_MASKED_LM_MAPPING






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

																					torch.cuda.empty_cache()






							@require_tf
							def 				_lowerCamelCase		(						self  ):
														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""": 38015, """token_str""": """ grouped"""},
														        {"""sequence""": """My name is accuser""", """score""": 2.1E-05, """token""": 25506, """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""": 38015,
														            """token_str""": """ grouped""",
														        },
														        {
														            """sequence""": """The largest city in France is accuser""",
														            """score""": 2.1E-05,
														            """token""": 25506,
														            """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""": 13606, """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 				_lowerCamelCase		(						self  ):
														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""": 35676, """token_str""": """ Maul"""},
														        {"""sequence""": """My name isELS""", """score""": 2.2E-05, """token""": 16416, """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""": 35676,
														            """token_str""": """ Maul""",
														        },
														        {"""sequence""": """The largest city in France isELS""", """score""": 2.2E-05, """token""": 16416, """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""": 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""": 13606, """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""": 35676,
														                """token_str""": """ Maul""",
														                """sequence""": """<s>My name is Maul<mask></s>""",
														            },
														            {"""score""": 2.2E-05, """token""": 16416, """token_str""": """ELS""", """sequence""": """<s>My name isELS<mask></s>"""},
														        ],
														        [
														            {
														                """score""": 2.2E-05,
														                """token""": 35676,
														                """token_str""": """ Maul""",
														                """sequence""": """<s>My name is<mask> Maul</s>""",
														            },
														            {"""score""": 2.2E-05, """token""": 16416, """token_str""": """ELS""", """sequence""": """<s>My name is<mask>ELS</s>"""},
														        ],
														    ]  , )






							@require_torch_gpu
							def 				_lowerCamelCase		(						self  ):
														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 				_lowerCamelCase		(						self  ):
														UpperCamelCase__				     =			pipeline(task="""fill-mask"""  , model="""distilroberta-base"""  , top_k=2  , framework="""pt"""  )
														self.run_large_test(__lowerCAmelCase  )






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






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														UpperCamelCase__				     =			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"""},
														    ]  , )
														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""": 2201,
														            """token_str""": """ Paris""",
														        },
														        {
														            """sequence""": """The largest city in France is Lyon""",
														            """score""": 0.214,
														            """token""": 12790,
														            """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""": 3499, """token_str""": """ Patrick"""},
														        {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 13606, """token_str""": """ Clara"""},
														        {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 2941, """token_str""": """ Te"""},
														    ]  , )






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






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






							def 				_lowerCamelCase		(						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)"""  )

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






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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 __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  ):
																					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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  ):
														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  )},
														        ],
														    ]  , )




