






import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
							from transformers.pipelines.conversational import Conversation

UpperCamelCase        =				logging.get_logger(__name__)


UpperCamelCase        =				{
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
    "tokenizer_config_file": "tokenizer_config.json",
}

UpperCamelCase        =				{
    "vocab_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"},
    "merges_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"},
    "tokenizer_config_file": {
        "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"
    },
}

UpperCamelCase        =				{"facebook/blenderbot-3B": 128}




@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def 				A		(					)		-> str:
	UpperCamelCase__ :Optional[int]						=      (
	    list(range(ord("""!"""  ) ,		ord("""~"""  ) + 1  )  ) + list(range(ord("""¡"""  ) ,		ord("""¬"""  ) + 1  )  ) + list(range(ord("""®"""  ) ,		ord("""ÿ"""  ) + 1  )  )
	)
	UpperCamelCase__ :List[str]						=      bs[:]
	UpperCamelCase__ :List[Any]						=      0
	for b in range(2**8  ):
		if b not in bs:
			bs.append(lowercase__  )
			cs.append(2**8 + n  )
			n += 1
	UpperCamelCase__ :List[Any]						=      [chr(lowercase__  ) for n in cs]
	return dict(zip(lowercase__ ,		lowercase__  )  )




def 				A		(					lowercase__  :  Dict  )		-> List[str]:
	UpperCamelCase__ :List[str]						=      set()
	UpperCamelCase__ :Union[str, Any]						=      word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)  )
		UpperCamelCase__ :List[Any]						=      char
	return pairs




class        lowerCAmelCase_				(      lowercase	):







				"""simple docstring"""




				_snake_case				:   Tuple        =			VOCAB_FILES_NAMES
				_snake_case				:   Any        =			PRETRAINED_VOCAB_FILES_MAP
				_snake_case				:   Optional[int]        =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				_snake_case				:   Any        =			["""input_ids""", """attention_mask"""]







				def __init__( self     :int  ,     lowerCamelCase__     :Optional[int]  ,     lowerCamelCase__     :int  ,     lowerCamelCase__     :int="replace"  ,     lowerCamelCase__     :Tuple="<s>"  ,     lowerCamelCase__     :Dict="</s>"  ,     lowerCamelCase__     :List[Any]="</s>"  ,     lowerCamelCase__     :int="<s>"  ,     lowerCamelCase__     :List[Any]="<unk>"  ,     lowerCamelCase__     :Any="<pad>"  ,     lowerCamelCase__     :int="<mask>"  ,     lowerCamelCase__     :List[Any]=False  ,     **lowerCamelCase__     :Dict  ,     ):
					UpperCamelCase__ :str						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else bos_token
					UpperCamelCase__ :Optional[Any]						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else eos_token
					UpperCamelCase__ :Any						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else sep_token
					UpperCamelCase__ :Dict						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else cls_token
					UpperCamelCase__ :Optional[Any]						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else unk_token
					UpperCamelCase__ :Union[str, Any]						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else pad_token

					# Mask token behave like a normal word, i.e. include the space before it
					UpperCamelCase__ :List[Any]						=      AddedToken(lowerCamelCase__  ,     lstrip=lowerCamelCase__  ,     rstrip=lowerCamelCase__     ) if isinstance(lowerCamelCase__  ,     lowerCamelCase__     ) else mask_token

					super().__init__(
					    errors=lowerCamelCase__  ,     bos_token=lowerCamelCase__  ,     eos_token=lowerCamelCase__  ,     unk_token=lowerCamelCase__  ,     sep_token=lowerCamelCase__  ,     cls_token=lowerCamelCase__  ,     pad_token=lowerCamelCase__  ,     mask_token=lowerCamelCase__  ,     add_prefix_space=lowerCamelCase__  ,     **lowerCamelCase__  ,     )

					with open(lowerCamelCase__  ,     encoding="""utf-8"""     ) as vocab_handle:
						UpperCamelCase__ :List[str]						=      json.load(lowerCamelCase__     )
					UpperCamelCase__ :Any						=      {v: k for k, v in self.encoder.items()}
					UpperCamelCase__ :List[Any]						=      errors  # how to handle errors in decoding
					UpperCamelCase__ :Union[str, Any]						=      bytes_to_unicode()
					UpperCamelCase__ :int						=      {v: k for k, v in self.byte_encoder.items()}
					with open(lowerCamelCase__  ,     encoding="""utf-8"""     ) as merges_handle:
						UpperCamelCase__ :Dict						=      merges_handle.read().split("""\n"""     )[1:-1]
					UpperCamelCase__ :Dict						=      [tuple(merge.split()     ) for merge in bpe_merges]
					UpperCamelCase__ :int						=      dict(zip(lowerCamelCase__  ,     range(len(lowerCamelCase__     )     )     )     )
					UpperCamelCase__ :Dict						=      {}
					UpperCamelCase__ :Optional[int]						=      add_prefix_space

					# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
					UpperCamelCase__ :str						=      re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""     )







				@property
				# Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
				def 				__a   ( self     :Dict     ):
					return len(self.encoder     )







				def 				__a   ( self     :Any     ):
					return dict(self.encoder  ,     **self.added_tokens_encoder     )







				def 				__a   ( self     :List[str]  ,     lowerCamelCase__     :Optional[Any]     ):
					if token in self.cache:
						return self.cache[token]
					UpperCamelCase__ :Tuple						=      tuple(lowerCamelCase__     )
					UpperCamelCase__ :Any						=      get_pairs(lowerCamelCase__     )

					if not pairs:
						return token

					while True:
						UpperCamelCase__ :Optional[int]						=      min(lowerCamelCase__  ,     key=lambda lowerCamelCase__     : self.bpe_ranks.get(lowerCamelCase__  ,     float("""inf"""     )     )     )
						if bigram not in self.bpe_ranks:
							break
						UpperCamelCase__				,		UpperCamelCase__ :Dict						=      bigram
						UpperCamelCase__ :Dict						=      []
						UpperCamelCase__ :Any						=      0
						while i < len(lowerCamelCase__     ):
							try:
								UpperCamelCase__ :Union[str, Any]						=      word.index(lowerCamelCase__  ,     lowerCamelCase__     )
							except ValueError:
								new_word.extend(word[i:]     )
								break
							else:
								new_word.extend(word[i:j]     )
								UpperCamelCase__ :Union[str, Any]						=      j

							if word[i] == first and i < len(lowerCamelCase__     ) - 1 and word[i + 1] == second:
								new_word.append(first + second     )
								i += 2
							else:
								new_word.append(word[i]     )
								i += 1
						UpperCamelCase__ :List[Any]						=      tuple(lowerCamelCase__     )
						UpperCamelCase__ :Optional[Any]						=      new_word
						if len(lowerCamelCase__     ) == 1:
							break
						else:
							UpperCamelCase__ :Union[str, Any]						=      get_pairs(lowerCamelCase__     )
					UpperCamelCase__ :Any						=      """ """.join(lowerCamelCase__     )
					UpperCamelCase__ :Dict						=      word
					return word







				def 				__a   ( self     :int  ,     lowerCamelCase__     :Optional[Any]     ):
					UpperCamelCase__ :Dict						=      []
					for token in re.findall(self.pat  ,     lowerCamelCase__     ):
						UpperCamelCase__ :Tuple						=      """""".join(
						    self.byte_encoder[b] for b in token.encode("""utf-8"""     )     )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
						bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCamelCase__     ).split(""" """     )     )
					return bpe_tokens







				def 				__a   ( self     :Union[str, Any]  ,     lowerCamelCase__     :str     ):
					return self.encoder.get(lowerCamelCase__  ,     self.encoder.get(self.unk_token     )     )







				def 				__a   ( self     :Optional[Any]  ,     lowerCamelCase__     :Dict     ):
					return self.decoder.get(lowerCamelCase__     )







				def 				__a   ( self     :Union[str, Any]  ,     lowerCamelCase__     :Optional[Any]     ):
					UpperCamelCase__ :str						=      """""".join(lowerCamelCase__     )
					UpperCamelCase__ :Tuple						=      bytearray([self.byte_decoder[c] for c in text]     ).decode("""utf-8"""  ,     errors=self.errors     )
					return text







				def 				__a   ( self     :List[Any]  ,     lowerCamelCase__     :str  ,     lowerCamelCase__     :Optional[str] = None     ):
					if not os.path.isdir(lowerCamelCase__     ):
						logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""     )
						return
					UpperCamelCase__ :Tuple						=      os.path.join(
					    lowerCamelCase__  ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]     )
					UpperCamelCase__ :Optional[Any]						=      os.path.join(
					    lowerCamelCase__  ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]     )

					with open(lowerCamelCase__  ,     """w"""  ,     encoding="""utf-8"""     ) as f:
						f.write(json.dumps(self.encoder  ,     indent=2  ,     sort_keys=lowerCamelCase__  ,     ensure_ascii=lowerCamelCase__     ) + """\n"""     )

					UpperCamelCase__ :str						=      0
					with open(lowerCamelCase__  ,     """w"""  ,     encoding="""utf-8"""     ) as writer:
						writer.write("""#version: 0.2\n"""     )
						for bpe_tokens, token_index in sorted(self.bpe_ranks.items()  ,     key=lambda lowerCamelCase__     : kv[1]     ):
							if index != token_index:
								logger.warning(
								    f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
								    """ Please check that the tokenizer is not corrupted!"""     )
								UpperCamelCase__ :Optional[int]						=      token_index
							writer.write(""" """.join(lowerCamelCase__     ) + """\n"""     )
							index += 1

					return vocab_file, merge_file







				def 				__a   ( self     :Optional[int]  ,     lowerCamelCase__     :List[int]  ,     lowerCamelCase__     :Optional[List[int]] = None  ,     lowerCamelCase__     :bool = False     ):
					if already_has_special_tokens:
						return super().get_special_tokens_mask(
						    token_ids_a=lowerCamelCase__  ,     token_ids_a=lowerCamelCase__  ,     already_has_special_tokens=lowerCamelCase__     )

					if token_ids_a is None:
						return [1] + ([0] * len(lowerCamelCase__     )) + [1]
					return [1] + ([0] * len(lowerCamelCase__     )) + [1, 1] + ([0] * len(lowerCamelCase__     )) + [1]







				def 				__a   ( self     :Union[str, Any]  ,     lowerCamelCase__     :List[int]  ,     lowerCamelCase__     :Optional[List[int]] = None     ):
					UpperCamelCase__ :Optional[Any]						=      [self.sep_token_id]
					UpperCamelCase__ :Dict						=      [self.cls_token_id]

					if token_ids_a is None:
						return len(cls + token_ids_a + sep     ) * [0]
					return len(cls + token_ids_a + sep + sep + token_ids_a + sep     ) * [0]







				def 				__a   ( self     :Optional[Any]  ,     lowerCamelCase__     :Dict  ,     lowerCamelCase__     :Tuple=False  ,     **lowerCamelCase__     :Any     ):
					UpperCamelCase__ :List[Any]						=      kwargs.pop("""add_prefix_space"""  ,     self.add_prefix_space     )
					if (is_split_into_words or add_prefix_space) and (len(lowerCamelCase__     ) > 0 and not text[0].isspace()):
						UpperCamelCase__ :List[str]						=      """ """ + text
					return (text, kwargs)







				def 				__a   ( self     :Optional[int]  ,     lowerCamelCase__     :List[int]  ,     lowerCamelCase__     :Optional[List[int]] = None     ):
					return token_ids_a + [self.eos_token_id]







				def 				__a   ( self     :Tuple  ,     lowerCamelCase__     :"Conversation"     ):
					UpperCamelCase__ :List[str]						=      []
					for is_user, text in conversation.iter_texts():
						if is_user:
							# We need to space prefix as it's being done within blenderbot
							inputs.append(""" """ + text     )
						else:
							# Generated responses should contain them already.
							inputs.append(lowerCamelCase__     )

					UpperCamelCase__ :Dict						=      """  """.join(lowerCamelCase__     )
					UpperCamelCase__ :List[str]						=      self.encode(lowerCamelCase__     )
					if len(lowerCamelCase__     ) > self.model_max_length:
						UpperCamelCase__ :Dict						=      input_ids[-self.model_max_length :]
						logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens."""     )
					return input_ids



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 ):
					snake_case_		:					int    					=						MODEL_FOR_MASKED_LM_MAPPING
					snake_case_		:					Optional[int]    					=						TF_MODEL_FOR_MASKED_LM_MAPPING


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Union[str, 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 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is grouped", "score": 2.1e-0_5, "token": 3_8_0_1_5, "token_str": " grouped"},
											        {"sequence": "My name is accuser", "score": 2.1e-0_5, "token": 2_5_5_0_6, "token_str": " accuser"},
											    ]  ,     )

											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {
											            "sequence": "The largest city in France is grouped",
											            "score": 2.1e-0_5,
											            "token": 3_8_0_1_5,
											            "token_str": " grouped",
											        },
											        {
											            "sequence": "The largest city in France is accuser",
											            "score": 2.1e-0_5,
											            "token": 2_5_5_0_6,
											            "token_str": " accuser",
											        },
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Patrick", "score": 2e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 1.9e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="pt"    )

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

											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {
											            "sequence": "The largest city in France is Maul",
											            "score": 2.2e-0_5,
											            "token": 3_5_6_7_6,
											            "token_str": " Maul",
											        },
											        {"sequence": "The largest city in France isELS", "score": 2.2e-0_5, "token": 1_6_4_1_6, "token_str": "ELS"},
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Patrick", "score": 2.1e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 2e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											    ]  ,     )

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

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


					@require_torch_gpu
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline("fill-mask"  ,     model="hf-internal-testing/tiny-random-distilbert"  ,     device=0  ,     framework="pt"    )

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

											__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(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )


					@slow
					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="pt"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					@slow
					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is John", "score": 0.008, "token": 6_1_0, "token_str": " John"},
											        {"sequence": "My name is Chris", "score": 0.007, "token": 1_5_7_3, "token_str": " Chris"},
											    ]  ,     )
											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {
											            "sequence": "The largest city in France is Paris",
											            "score": 0.251,
											            "token": 2_2_0_1,
											            "token_str": " Paris",
											        },
											        {
											            "sequence": "The largest city in France is Lyon",
											            "score": 0.214,
											            "token": 1_2_7_9_0,
											            "token_str": " Lyon",
											        },
											    ]  ,     )

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


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						str:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="pt"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="tf"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		Tuple    )      ->						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)"    )

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[
											    f'''This is another {tokenizer.mask_token} test''',
											]
											return fill_masker, examples


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		fill_masker.tokenizer
											__snake_case				=		fill_masker.model

											__snake_case				=		fill_masker(
											    f'''This is a {tokenizer.mask_token}'''  ,     )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

											__snake_case				=		fill_masker([f'''This is a {tokenizer.mask_token}''']    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

											__snake_case				=		fill_masker([f'''This is a {tokenizer.mask_token}''', f'''Another {tokenizer.mask_token} great test.''']    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											    ]  ,     )

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]    )      ->						Any:




											'''simple docstring'''

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

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

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     top_k=2    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		List[Any]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Dict    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer.get_vocab()
											# String duplicates + id duplicates
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__snake_case				=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
											__snake_case				=		fill_masker(f'''My name is {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE  ,     top_k=1_0    )

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






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

											__snake_case				=		fill_masker(
											    f'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''  ,     top_k=2    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											        [
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											            {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        ],
											    ]  ,     )





