





"""simple docstring"""




from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor


class 			__UpperCamelCase							:






							def __init__(  self ,   lowerCAmelCase__ ,   lowerCAmelCase__=3 ,   lowerCAmelCase__=32 ,   lowerCAmelCase__=3 ,   lowerCAmelCase__=10 ,   lowerCAmelCase__=[10, 20, 30, 40] ,   lowerCAmelCase__=[1, 1, 2, 1] ,   lowerCAmelCase__=True ,   lowerCAmelCase__=True ,   lowerCAmelCase__="relu" ,   lowerCAmelCase__=3 ,   lowerCAmelCase__=None ,   )      ->					List[str]:
								a :						Optional[Any]      =							parent
								a :						str      =							batch_size
								a :						str      =							image_size
								a :						Tuple      =							num_channels
								a :						Tuple      =							embeddings_size
								a :						Optional[Any]      =							hidden_sizes
								a :						Optional[int]      =							depths
								a :						Any      =							is_training
								a :						Tuple      =							use_labels
								a :						str      =							hidden_act
								a :						Optional[Any]      =							num_labels
								a :						Dict      =							scope
								a :						int      =							len(lowerCAmelCase__ )






							def        __a  (  self )      ->					Optional[int]:
								a :						str      =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

								a :						Tuple      =							None
								if self.use_labels:
									a :						int      =							ids_tensor([self.batch_size] ,   self.num_labels )

								a :						Dict      =							self.get_config()
								return config, pixel_values, labels






							def        __a  (  self )      ->					List[Any]:
								return RegNetConfig(
								    num_channels=self.num_channels ,   embeddings_size=self.embeddings_size ,   hidden_sizes=self.hidden_sizes ,   depths=self.depths ,   hidden_act=self.hidden_act ,   num_labels=self.num_labels ,   )






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					List[str]:
								a :						Union[str, Any]      =							TFRegNetModel(config=lowerCAmelCase__ )
								a :						Optional[int]      =							model(lowerCAmelCase__ ,   training=lowerCAmelCase__ )
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape ,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,   )






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[Any]:
								a :						Any      =							self.num_labels
								a :						Optional[Any]      =							TFRegNetForImageClassification(lowerCAmelCase__ )
								a :						List[Any]      =							model(lowerCAmelCase__ ,   labels=lowerCAmelCase__ ,   training=lowerCAmelCase__ )
								self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels) )






							def        __a  (  self )      ->					Any:
								a :						Union[str, Any]      =							self.prepare_config_and_inputs()
								a,			a,			a :						str      =							config_and_inputs
								a :						int      =							{"pixel_values": pixel_values}
								return config, inputs_dict


@require_tf
class 			__UpperCamelCase							(		a__						,			a__						,			unittest.TestCase		):
							lowerCamelCase  :   int    =(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
							lowerCamelCase  :   Optional[Any]    =(
							    {"""feature-extraction""": TFRegNetModel, """image-classification""": TFRegNetForImageClassification}
							    if is_tf_available()
							    else {}
							)

							lowerCamelCase  :   int    =False
							lowerCamelCase  :   Optional[Any]    =False
							lowerCamelCase  :   List[str]    =False
							lowerCamelCase  :   str    =False
							lowerCamelCase  :   Dict    =False






							def        __a  (  self )      ->					Dict:
								a :						str      =							TFRegNetModelTester(self )
								a :						Union[str, Any]      =							ConfigTester(self ,   config_class=lowerCAmelCase__ ,   has_text_modality=lowerCAmelCase__ )






							def        __a  (  self )      ->					Optional[int]:
								return






							@unittest.skip(reason="RegNet does not use inputs_embeds" )
							def        __a  (  self )      ->					Tuple:
								pass






							@unittest.skipIf(
							    not is_tf_available() or len(tf.config.list_physical_devices("GPU" ) ) == 0 ,   reason="TF does not support backprop for grouped convolutions on CPU." ,   )
							@slow
							def        __a  (  self )      ->					Optional[Any]:
								super().test_keras_fit()






							@unittest.skip(reason="RegNet does not support input and output embeddings" )
							def        __a  (  self )      ->					Dict:
								pass






							def        __a  (  self )      ->					str:
								a,			a :						Optional[int]      =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									a :						Any      =							model_class(lowerCAmelCase__ )
									a :						Optional[int]      =							inspect.signature(model.call )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									a :						List[str]      =							[*signature.parameters.keys()]

									a :						Union[str, Any]      =							["pixel_values"]
									self.assertListEqual(arg_names[:1] ,   lowerCAmelCase__ )






							def        __a  (  self )      ->					int:
								a :						str      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase__ )






							def        __a  (  self )      ->					str:
								def check_hidden_states_output(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ):
									a :						List[str]      =							model_class(lowerCAmelCase__ )
									a :						Dict      =							model(**self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ) ,   training=lowerCAmelCase__ )

									a :						str      =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									a :						Optional[int]      =							self.model_tester.num_stages
									self.assertEqual(len(lowerCAmelCase__ ) ,   expected_num_stages + 1 )

									# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
									self.assertListEqual(
									    list(hidden_states[0].shape[-2:] ) ,   [self.model_tester.image_size // 2, self.model_tester.image_size // 2] ,   )

								a,			a :						int      =							self.model_tester.prepare_config_and_inputs_for_common()
								a :						str      =							["basic", "bottleneck"]
								for model_class in self.all_model_classes:
									for layer_type in layers_type:
										a :						Any      =							layer_type
										a :						Optional[Any]      =							True
										check_hidden_states_output(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										a :						int      =							True

										check_hidden_states_output(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )






							def        __a  (  self )      ->					Optional[Any]:
								a,			a :						str      =							self.model_tester.prepare_config_and_inputs_for_common()

								def check_equivalence(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__={} ):
									a :						List[str]      =							model(lowerCAmelCase__ ,   return_dict=lowerCAmelCase__ ,   **lowerCAmelCase__ )
									a :						List[Any]      =							model(lowerCAmelCase__ ,   return_dict=lowerCAmelCase__ ,   **lowerCAmelCase__ ).to_tuple()

									def recursive_check(lowerCAmelCase__ ,   lowerCAmelCase__ ):
										if isinstance(lowerCAmelCase__ ,   (List, Tuple) ):
											for tuple_iterable_value, dict_iterable_value in zip(lowerCAmelCase__ ,   lowerCAmelCase__ ):
												recursive_check(lowerCAmelCase__ ,   lowerCAmelCase__ )
										elif tuple_object is None:
											return
										else:
											self.assertTrue(
											    all(tf.equal(lowerCAmelCase__ ,   lowerCAmelCase__ ) ) ,   msg=(
											        "Tuple and dict output are not equal. Difference:"
											        f""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object ) )}"""
											    ) ,   )

										recursive_check(lowerCAmelCase__ ,   lowerCAmelCase__ )

								for model_class in self.all_model_classes:
									a :						int      =							model_class(lowerCAmelCase__ )

									a :						str      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ )
									a :						Union[str, Any]      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ )
									check_equivalence(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )

									a :						str      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ,   return_labels=lowerCAmelCase__ )
									a :						str      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ,   return_labels=lowerCAmelCase__ )
									check_equivalence(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )

									a :						Optional[Any]      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ )
									a :						Optional[int]      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ )
									check_equivalence(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   {"output_hidden_states": True} )

									a :						Optional[Any]      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ,   return_labels=lowerCAmelCase__ )
									a :						Dict      =							self._prepare_for_class(lowerCAmelCase__ ,   lowerCAmelCase__ ,   return_labels=lowerCAmelCase__ )
									check_equivalence(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   {"output_hidden_states": True} )






							def        __a  (  self )      ->					Dict:
								a :						str      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__ )






							@slow
							def        __a  (  self )      ->					Union[str, Any]:
								for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									a :						Tuple      =							TFRegNetModel.from_pretrained(lowerCAmelCase__ )
									self.assertIsNotNone(lowerCAmelCase__ )






def  _SCREAMING_SNAKE_CASE						(      )					->str:






	'''simple docstring'''






	a :						List[Any]      =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
	return image







@require_tf
@require_vision
class 			__UpperCamelCase							(		unittest.TestCase		):






							@cached_property
							def        __a  (  self )      ->					Any:
								return (
								    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
								    if is_vision_available()
								    else None
								)






							@slow
							def        __a  (  self )      ->					str:
								a :						int      =							TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )

								a :						int      =							self.default_image_processor
								a :						Optional[int]      =							prepare_img()
								a :						List[str]      =							image_processor(images=lowerCAmelCase__ ,   return_tensors="tf" )

								# forward pass
								a :						List[Any]      =							model(**lowerCAmelCase__ ,   training=lowerCAmelCase__ )

								# verify the logits
								a :						Optional[int]      =							tf.TensorShape((1, 1000) )
								self.assertEqual(outputs.logits.shape ,   lowerCAmelCase__ )

								a :						Any      =							tf.constant([-0.4_180, -1.5_051, -3.4_836] )

								tf.debugging.assert_near(outputs.logits[0, :3] ,   lowerCAmelCase__ ,   atol=1E-4 )









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


