





"""simple docstring"""




import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union

import numpy as np






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       bytes       ,			_lowercase		:       int   )					->np.array:






	'''simple docstring'''






	a :						Any      =							F"""{sampling_rate}"""
	a :						Optional[int]      =							"1"
	a :						int      =							"f32le"
	a :						List[Any]      =							[
	    "ffmpeg",
	    "-i",
	    "pipe:0",
	    "-ac",
	    ac,
	    "-ar",
	    ar,
	    "-f",
	    format_for_conversion,
	    "-hide_banner",
	    "-loglevel",
	    "quiet",
	    "pipe:1",
	]

	try:
		with subprocess.Popen(_lowercase       ,			stdin=subprocess.PIPE       ,			stdout=subprocess.PIPE   ) as ffmpeg_process:
			a :						Tuple      =							ffmpeg_process.communicate(_lowercase   )
	except FileNotFoundError as error:
		raise ValueError("ffmpeg was not found but is required to load audio files from filename"   ) from error
	a :						Optional[int]      =							output_stream[0]
	a :						Any      =							np.frombuffer(_lowercase       ,			np.floataa   )
	if audio.shape[0] == 0:
		raise ValueError("Malformed soundfile"   )
	return audio






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       int       ,			_lowercase		:       float       ,			_lowercase		:       str = "f32le"       ,			)					->Union[str, Any]:






	'''simple docstring'''






	a :						Optional[Any]      =							F"""{sampling_rate}"""
	a :						List[str]      =							"1"
	if format_for_conversion == "s16le":
		a :						Tuple      =							2
	elif format_for_conversion == "f32le":
		a :						Optional[Any]      =							4
	else:
		raise ValueError(F"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`"""   )

	a :						Optional[int]      =							platform.system()
	if system == "Linux":
		a :						Optional[Any]      =							"alsa"
		a :						Union[str, Any]      =							"default"
	elif system == "Darwin":
		a :						List[Any]      =							"avfoundation"
		a :						str      =							":0"
	elif system == "Windows":
		a :						List[str]      =							"dshow"
		a :						str      =							"default"

	a :						Optional[Any]      =							[
	    "ffmpeg",
	    "-f",
	    format_,
	    "-i",
	    input_,
	    "-ac",
	    ac,
	    "-ar",
	    ar,
	    "-f",
	    format_for_conversion,
	    "-fflags",
	    "nobuffer",
	    "-hide_banner",
	    "-loglevel",
	    "quiet",
	    "pipe:1",
	]
	a :						Dict      =							int(round(sampling_rate * chunk_length_s   )   ) * size_of_sample
	a :						Union[str, Any]      =							_ffmpeg_stream(_lowercase       ,			_lowercase   )
	for item in iterator:
		yield item






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       int       ,			_lowercase		:       float       ,			_lowercase		:       Optional[int] = None       ,			_lowercase		:       Optional[Union[Tuple[float, float], float]] = None       ,			_lowercase		:       str = "f32le"       ,			)					->str:






	'''simple docstring'''






	if stream_chunk_s is not None:
		a :						int      =							stream_chunk_s
	else:
		a :						List[Any]      =							chunk_length_s

	a :						Optional[int]      =							ffmpeg_microphone(_lowercase       ,			_lowercase       ,			format_for_conversion=_lowercase   )
	if format_for_conversion == "s16le":
		a :						str      =							np.intaa
		a :						Optional[int]      =							2
	elif format_for_conversion == "f32le":
		a :						Optional[Any]      =							np.floataa
		a :						Optional[int]      =							4
	else:
		raise ValueError(F"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`"""   )

	if stride_length_s is None:
		a :						Optional[Any]      =							chunk_length_s / 6
	a :						List[Any]      =							int(round(sampling_rate * chunk_length_s   )   ) * size_of_sample
	if isinstance(_lowercase       ,			(int, float)   ):
		a :						Any      =							[stride_length_s, stride_length_s]

	a :						Tuple      =							int(round(sampling_rate * stride_length_s[0]   )   ) * size_of_sample
	a :						int      =							int(round(sampling_rate * stride_length_s[1]   )   ) * size_of_sample
	a :						Any      =							datetime.datetime.now()
	a :						int      =							datetime.timedelta(seconds=_lowercase   )
	for item in chunk_bytes_iter(_lowercase       ,			_lowercase       ,			stride=(stride_left, stride_right)       ,			stream=_lowercase   ):
		# Put everything back in numpy scale
		a :						List[Any]      =							np.frombuffer(item["raw"]       ,			dtype=_lowercase   )
		a :						str      =							(
		    item["stride"][0] // size_of_sample,
		    item["stride"][1] // size_of_sample,
		)
		a :						Any      =							sampling_rate
		audio_time += delta
		if datetime.datetime.now() > audio_time + 10 * delta:
			# We're late !! SKIP
			continue
		yield item






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Optional[Any]       ,			_lowercase		:       int       ,			_lowercase		:       Tuple[int, int]       ,			_lowercase		:       bool = False   )					->Optional[Any]:






	'''simple docstring'''






	a :						Dict      =							B""
	a,			a :						Dict      =							stride
	if stride_left + stride_right >= chunk_len:
		raise ValueError(
		    F"""Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}"""   )
	a :						Dict      =							0
	for raw in iterator:
		acc += raw
		if stream and len(_lowercase   ) < chunk_len:
			a :						str      =							(_stride_left, 0)
			yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
		else:
			while len(_lowercase   ) >= chunk_len:
				# We are flushing the accumulator
				a :						List[str]      =							(_stride_left, stride_right)
				a :						Any      =							{"raw": acc[:chunk_len], "stride": stride}
				if stream:
					a :						int      =							False
				yield item
				a :						Optional[int]      =							stride_left
				a :						Union[str, Any]      =							acc[chunk_len - stride_left - stride_right :]
    # Last chunk
	if len(_lowercase   ) > stride_left:
		a :						Union[str, Any]      =							{"raw": acc, "stride": (_stride_left, 0)}
		if stream:
			a :						Any      =							False
		yield item







def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       List[str]       ,			_lowercase		:       int   )					->Optional[Any]:






	'''simple docstring'''






	a :						Optional[Any]      =							2**24  # 16Mo
	try:
		with subprocess.Popen(_lowercase       ,			stdout=subprocess.PIPE       ,			bufsize=_lowercase   ) as ffmpeg_process:
			while True:
				a :						Union[str, Any]      =							ffmpeg_process.stdout.read(_lowercase   )
				if raw == b"":
					break
				yield raw
	except FileNotFoundError as error:
		raise ValueError("ffmpeg was not found but is required to stream audio files from filename"   ) from error









"""simple docstring"""




import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY


@is_pipeline_test
class 			__UpperCamelCase							(		unittest.TestCase		):
							lowerCamelCase  :   Union[str, Any]    =MODEL_FOR_MASKED_LM_MAPPING
							lowerCamelCase  :   List[str]    =TF_MODEL_FOR_MASKED_LM_MAPPING






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

									torch.cuda.empty_cache()






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

								a :						str      =							unmasker("The largest city in France is <mask>" )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {
								            "sequence": "The largest city in France is grouped",
								            "score": 2.1E-05,
								            "token": 3_8015,
								            "token_str": " grouped",
								        },
								        {
								            "sequence": "The largest city in France is accuser",
								            "score": 2.1E-05,
								            "token": 2_5506,
								            "token_str": " accuser",
								        },
								    ] ,   )

								a :						Any      =							unmasker("My name is <mask>" ,   targets=[" Patrick", " Clara", " Teven"] ,   top_k=3 )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {"sequence": "My name is Clara", "score": 2E-05, "token": 1_3606, "token_str": " Clara"},
								        {"sequence": "My name is Patrick", "score": 2E-05, "token": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Te", "score": 1.9E-05, "token": 2941, "token_str": " Te"},
								    ] ,   )






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

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

								a :						Optional[Any]      =							unmasker("The largest city in France is <mask>" )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {
								            "sequence": "The largest city in France is Maul",
								            "score": 2.2E-05,
								            "token": 3_5676,
								            "token_str": " Maul",
								        },
								        {"sequence": "The largest city in France isELS", "score": 2.2E-05, "token": 1_6416, "token_str": "ELS"},
								    ] ,   )

								a :						List[str]      =							unmasker("My name is <mask>" ,   targets=[" Patrick", " Clara", " Teven"] ,   top_k=3 )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ,   decimals=6 ) ,   [
								        {"sequence": "My name is Patrick", "score": 2.1E-05, "token": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Te", "score": 2E-05, "token": 2941, "token_str": " Te"},
								        {"sequence": "My name is Clara", "score": 2E-05, "token": 1_3606, "token_str": " Clara"},
								    ] ,   )

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

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






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

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

								a :						Optional[Any]      =							pipe("Paris is the [MASK] of France." )
								# We actually don't care about the result, we just want to make sure
								# it works, meaning the float16 tensor got casted back to float32
								# for postprocessing.
								self.assertIsInstance(lowerCAmelCase__ ,   lowerCAmelCase__ )






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






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






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

								a :						Tuple      =							unmasker("My name is <mask>" ,   targets=[" Patrick", " Clara", " Teven"] ,   top_k=3 )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__ ) ,   [
								        {"sequence": "My name is Patrick", "score": 0.005, "token": 3499, "token_str": " Patrick"},
								        {"sequence": "My name is Clara", "score": 0.000, "token": 1_3606, "token_str": " Clara"},
								        {"sequence": "My name is Te", "score": 0.000, "token": 2941, "token_str": " Te"},
								    ] ,   )






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






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






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

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






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

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

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

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

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

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






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Dict:
								a :						Union[str, Any]      =							tokenizer.get_vocab()
								a :						List[Any]      =							sorted(vocab.keys() )[:2]
								# Pipeline argument
								a :						str      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ ,   targets=lowerCAmelCase__ )
								a :						Dict      =							fill_masker(f"""This is a {tokenizer.mask_token}""" )
								self.assertEqual(
								    lowerCAmelCase__ ,   [
								        {"sequence": ANY(lowerCAmelCase__ ), "score": ANY(lowerCAmelCase__ ), "token": ANY(lowerCAmelCase__ ), "token_str": ANY(lowerCAmelCase__ )},
								        {"sequence": ANY(lowerCAmelCase__ ), "score": ANY(lowerCAmelCase__ ), "token": ANY(lowerCAmelCase__ ), "token_str": ANY(lowerCAmelCase__ )},
								    ] ,   )
								a :						List[str]      =							{vocab[el] for el in targets}
								self.assertEqual({el["token"] for el in outputs} ,   lowerCAmelCase__ )
								a :						str      =							[tokenizer.decode([x] ) for x in target_ids]
								self.assertEqual({el["token_str"] for el in outputs} ,   set(lowerCAmelCase__ ) )

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

								# Score equivalence
								a :						Tuple      =							fill_masker(f"""This is a {tokenizer.mask_token}""" ,   targets=lowerCAmelCase__ )
								a :						List[str]      =							[top_mask["token_str"] for top_mask in outputs]
								a :						Dict      =							[top_mask["score"] for top_mask in outputs]

								# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
								if set(lowerCAmelCase__ ) == set(lowerCAmelCase__ ):
									a :						Union[str, Any]      =							fill_masker(f"""This is a {tokenizer.mask_token}""" ,   targets=lowerCAmelCase__ )
									a :						Tuple      =							[top_mask["score"] for top_mask in unmasked_targets]
									self.assertEqual(nested_simplify(lowerCAmelCase__ ) ,   nested_simplify(lowerCAmelCase__ ) )

								# Raises with invalid
								with self.assertRaises(lowerCAmelCase__ ):
									a :						Tuple      =							fill_masker(f"""This is a {tokenizer.mask_token}""" ,   targets=[] )
								# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
								if "" not in tokenizer.get_vocab():
									with self.assertRaises(lowerCAmelCase__ ):
										a :						List[Any]      =							fill_masker(f"""This is a {tokenizer.mask_token}""" ,   targets=[""] )
									with self.assertRaises(lowerCAmelCase__ ):
										a :						Optional[int]      =							fill_masker(f"""This is a {tokenizer.mask_token}""" ,   targets="" )






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[Any]:
								a :						int      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ ,   top_k=2 )
								a :						List[Any]      =							fill_masker(f"""This is a {tokenizer.mask_token}""" )
								self.assertEqual(
								    lowerCAmelCase__ ,   [
								        {"sequence": ANY(lowerCAmelCase__ ), "score": ANY(lowerCAmelCase__ ), "token": ANY(lowerCAmelCase__ ), "token_str": ANY(lowerCAmelCase__ )},
								        {"sequence": ANY(lowerCAmelCase__ ), "score": ANY(lowerCAmelCase__ ), "token": ANY(lowerCAmelCase__ ), "token_str": ANY(lowerCAmelCase__ )},
								    ] ,   )

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






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					str:
								a :						Tuple      =							tokenizer.get_vocab()
								a :						List[str]      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )

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

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






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Any:
								a :						Tuple      =							FillMaskPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								a :						Union[str, Any]      =							tokenizer.get_vocab()
								# String duplicates + id duplicates
								a :						Optional[Any]      =							sorted(vocab.keys() )[:3]
								a :						int      =							[targets[0], targets[1], targets[0], targets[2], targets[1]]
								a :						Tuple      =							fill_masker(f"""My name is {tokenizer.mask_token}""" ,   targets=lowerCAmelCase__ ,   top_k=10 )

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






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

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


