





"""simple docstring"""




from __future__ import annotations

a		:					Any	      =     tuple[int, int, int]
a		:					str	      =     tuple[str, str, str]


# used alphabet --------------------------
# from string.ascii_uppercase
a		:					Tuple	      =     '''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''

# -------------------------- default selection --------------------------
# rotors --------------------------
a		:					Any	      =     '''EGZWVONAHDCLFQMSIPJBYUKXTR'''
a		:					List[Any]	      =     '''FOBHMDKEXQNRAULPGSJVTYICZW'''
a		:					List[Any]	      =     '''ZJXESIUQLHAVRMDOYGTNFWPBKC'''
# reflector --------------------------
a		:					Union[str, Any]	      =     {
    '''A''': '''N''',
    '''N''': '''A''',
    '''B''': '''O''',
    '''O''': '''B''',
    '''C''': '''P''',
    '''P''': '''C''',
    '''D''': '''Q''',
    '''Q''': '''D''',
    '''E''': '''R''',
    '''R''': '''E''',
    '''F''': '''S''',
    '''S''': '''F''',
    '''G''': '''T''',
    '''T''': '''G''',
    '''H''': '''U''',
    '''U''': '''H''',
    '''I''': '''V''',
    '''V''': '''I''',
    '''J''': '''W''',
    '''W''': '''J''',
    '''K''': '''X''',
    '''X''': '''K''',
    '''L''': '''Y''',
    '''Y''': '''L''',
    '''M''': '''Z''',
    '''Z''': '''M''',
}

# -------------------------- extra rotors --------------------------
a		:					List[Any]	      =     '''RMDJXFUWGISLHVTCQNKYPBEZOA'''
a		:					List[Any]	      =     '''SGLCPQWZHKXAREONTFBVIYJUDM'''
a		:					Optional[int]	      =     '''HVSICLTYKQUBXDWAJZOMFGPREN'''
a		:					Any	      =     '''RZWQHFMVDBKICJLNTUXAGYPSOE'''
a		:					Optional[int]	      =     '''LFKIJODBEGAMQPXVUHYSTCZRWN'''
a		:					List[Any]	      =     '''KOAEGVDHXPQZMLFTYWJNBRCIUS'''






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       RotorPositionT       ,			_lowercase		:       RotorSelectionT       ,			_lowercase		:       str   )					->tuple[RotorPositionT, RotorSelectionT, dict[str, str]]:






	'''simple docstring'''






	if (unique_rotsel := len(set(_lowercase   )   )) < 3:
		a :						Optional[Any]      =							F"""Please use 3 unique rotors (not {unique_rotsel})"""
		raise Exception(_lowercase   )

	# Checks if rotor positions are valid
	a,			a,			a :						int      =							rotpos
	if not 0 < rotorposa <= len(_lowercase   ):
		a :						List[str]      =							F"""First rotor position is not within range of 1..26 ({rotorposa}"""
		raise ValueError(_lowercase   )
	if not 0 < rotorposa <= len(_lowercase   ):
		a :						Optional[Any]      =							F"""Second rotor position is not within range of 1..26 ({rotorposa})"""
		raise ValueError(_lowercase   )
	if not 0 < rotorposa <= len(_lowercase   ):
		a :						Optional[Any]      =							F"""Third rotor position is not within range of 1..26 ({rotorposa})"""
		raise ValueError(_lowercase   )

	# Validates string and returns dict
	a :						Optional[Any]      =							_plugboard(_lowercase   )

	return rotpos, rotsel, pbdict






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       str   )					->dict[str, str]:






	'''simple docstring'''






	if not isinstance(_lowercase       ,			_lowercase   ):
		a :						str      =							F"""Plugboard setting isn't type string ({type(_lowercase   )})"""
		raise TypeError(_lowercase   )
	elif len(_lowercase   ) % 2 != 0:
		a :						Any      =							F"""Odd number of symbols ({len(_lowercase   )})"""
		raise Exception(_lowercase   )
	elif pbstring == "":
		return {}

	pbstring.replace(" "       ,			""   )

	# Checks if all characters are unique
	a :						List[str]      =							set()
	for i in pbstring:
		if i not in abc:
			a :						str      =							F"""'{i}' not in list of symbols"""
			raise Exception(_lowercase   )
		elif i in tmppbl:
			a :						Tuple      =							F"""Duplicate symbol ({i})"""
			raise Exception(_lowercase   )
		else:
			tmppbl.add(_lowercase   )
	del tmppbl

	# Created the dictionary
	a :						List[str]      =							{}
	for j in range(0       ,			len(_lowercase   ) - 1       ,			2   ):
		a :						int      =							pbstring[j + 1]
		a :						Optional[Any]      =							pbstring[j]

	return pb






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       str       ,			_lowercase		:       RotorPositionT       ,			_lowercase		:       RotorSelectionT = (rotora, rotora, rotora)       ,			_lowercase		:       str = ""       ,			)					->str:






	'''simple docstring'''






	a :						Dict      =							text.upper()
	a,			a,			a :						Tuple      =							_validator(
	    _lowercase       ,			_lowercase       ,			plugb.upper()   )

	a,			a,			a :						Optional[int]      =							rotor_position
	a,			a,			a :						List[str]      =							rotor_selection
	rotorposa -= 1
	rotorposa -= 1
	rotorposa -= 1

	a :						Any      =							[]

	# encryption/decryption process --------------------------
	for symbol in text:
		if symbol in abc:
			# 1st plugboard --------------------------
			if symbol in plugboard:
				a :						Optional[int]      =							plugboard[symbol]

			# rotor ra --------------------------
			a :						List[str]      =							abc.index(_lowercase   ) + rotorposa
			a :						List[str]      =							rotora[index % len(_lowercase   )]

			# rotor rb --------------------------
			a :						Optional[Any]      =							abc.index(_lowercase   ) + rotorposa
			a :						str      =							rotora[index % len(_lowercase   )]

			# rotor rc --------------------------
			a :						Optional[Any]      =							abc.index(_lowercase   ) + rotorposa
			a :						Tuple      =							rotora[index % len(_lowercase   )]

			# reflector --------------------------
			# this is the reason you don't need another machine to decipher

			a :						Dict      =							reflector[symbol]

			# 2nd rotors
			a :						List[Any]      =							abc[rotora.index(_lowercase   ) - rotorposa]
			a :						Any      =							abc[rotora.index(_lowercase   ) - rotorposa]
			a :						Any      =							abc[rotora.index(_lowercase   ) - rotorposa]

			# 2nd plugboard
			if symbol in plugboard:
				a :						Tuple      =							plugboard[symbol]

			# moves/resets rotor positions
			rotorposa += 1
			if rotorposa >= len(_lowercase   ):
				a :						int      =							0
				rotorposa += 1
			if rotorposa >= len(_lowercase   ):
				a :						Union[str, Any]      =							0
				rotorposa += 1
			if rotorposa >= len(_lowercase   ):
				a :						Optional[Any]      =							0

        # else:
        #    pass
        #    Error could be also raised
        #    raise ValueError(
        #       'Invalid symbol('+repr(symbol)+')')
		result.append(_lowercase   )

	return "".join(_lowercase   )


if __name__ == "__main__":
		a		:					Any	      =     '''This is my Python script that emulates the Enigma machine from WWII.'''
		a		:					List[str]	      =     (1, 1, 1)
		a		:					Optional[Any]	      =     '''pictures'''
		a		:					int	      =     (rotora, rotora, rotora)
		a		:					int	      =     enigma(message, rotor_pos, rotor_sel, pb)

		print('''Encrypted message:''', en)
		print('''Decrypted message:''', enigma(en, rotor_pos, rotor_sel, pb))









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


