



"""simple docstring"""







import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import SwiftFormerForImageClassification, SwiftFormerModel
							from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import ViTImageProcessor






class      UpperCAmelCase__		:



		def __init__( self  :    List[str]      ,							snake_case  :    int      ,							snake_case  :    List[str]=13      ,							snake_case  :    Any=3      ,							snake_case  :    Optional[int]=True      ,							snake_case  :    str=True      ,							snake_case  :    Optional[Any]=0.1      ,							snake_case  :    List[Any]=0.1      ,							snake_case  :    Any=224      ,							snake_case  :    str=1_000      ,							snake_case  :    Any=[3, 3, 6, 4]      ,							snake_case  :    Tuple=[48, 56, 112, 220]      ,							)			->						int:






									'''simple docstring'''

									A         =					parent
									A         =					batch_size
									A         =					num_channels
									A         =					is_training
									A         =					use_labels
									A         =					hidden_dropout_prob
									A         =					attention_probs_dropout_prob
									A         =					num_labels
									A         =					image_size
									A         =					layer_depths
									A         =					embed_dims



		def 					A_		( self  :    Dict				)			->						List[Any]:






									'''simple docstring'''

									A         =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

									A         =					None
									if self.use_labels:
																A         =					ids_tensor([self.batch_size]      ,							self.num_labels				)

									A         =					self.get_config()

									return config, pixel_values, labels



		def 					A_		( self  :    Optional[int]				)			->						List[Any]:






									'''simple docstring'''

									return SwiftFormerConfig(
									    depths=self.layer_depths      ,							embed_dims=self.embed_dims      ,							mlp_ratio=4      ,							downsamples=[True, True, True, True]      ,							hidden_act='gelu'      ,							num_labels=self.num_labels      ,							down_patch_size=3      ,							down_stride=2      ,							down_pad=1      ,							drop_rate=0.0      ,							drop_path_rate=0.0      ,							use_layer_scale=_UpperCAmelCase      ,							layer_scale_init_value=1E-5      ,							)



		def 					A_		( self  :    int      ,							snake_case  :    Dict      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    int				)			->						Optional[int]:






									'''simple docstring'''

									A         =					SwiftFormerModel(config=_UpperCAmelCase				)
									model.to(_UpperCAmelCase				)
									model.eval()
									A         =					model(_UpperCAmelCase				)
									self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.embed_dims[-1], 7, 7)				)



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






									'''simple docstring'''

									A         =					self.num_labels
									A         =					SwiftFormerForImageClassification(_UpperCAmelCase				)
									model.to(_UpperCAmelCase				)
									model.eval()
									A         =					model(_UpperCAmelCase      ,							labels=_UpperCAmelCase				)
									self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_labels)				)

									A         =					SwiftFormerForImageClassification(_UpperCAmelCase				)
									model.to(_UpperCAmelCase				)
									model.eval()

									A         =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
									A         =					model(_UpperCAmelCase				)
									self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_labels)				)



		def 					A_		( self  :    List[str]				)			->						Union[str, Any]:






									'''simple docstring'''

									(A)         =					self.prepare_config_and_inputs()
									A         =					{'''pixel_values''': pixel_values}
									return config, inputs_dict






@require_torch
class      UpperCAmelCase__		(      _UpperCamelCase   ,_UpperCamelCase   ,unittest.TestCase     ):
		lowerCAmelCase_       :	int 							=     (SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
		lowerCAmelCase_       :	Dict 							=     (
		    {"""feature-extraction""": SwiftFormerModel, """image-classification""": SwiftFormerForImageClassification}
		    if is_torch_available()
		    else {}
		)

		lowerCAmelCase_       :	str 							=     False
		lowerCAmelCase_       :	Union[str, Any] 							=     False
		lowerCAmelCase_       :	Optional[int] 							=     False
		lowerCAmelCase_       :	List[Any] 							=     False
		lowerCAmelCase_       :	List[str] 							=     False



		def 					A_		( self  :    str				)			->						Optional[int]:






									'''simple docstring'''

									A         =					SwiftFormerModelTester(self				)
									A         =					ConfigTester(
									    self      ,							config_class=_UpperCAmelCase      ,							has_text_modality=_UpperCAmelCase      ,							hidden_size=37      ,							num_attention_heads=12      ,							num_hidden_layers=12      ,							)



		def 					A_		( self  :    Tuple				)			->						Any:






									'''simple docstring'''

									self.config_tester.run_common_tests()



		@unittest.skip(reason='SwiftFormer does not use inputs_embeds'				)
		def 					A_		( self  :    Tuple				)			->						List[str]:






									'''simple docstring'''

									pass



		def 					A_		( self  :    Optional[Any]				)			->						str:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																A         =					model_class(_UpperCAmelCase				)
																A         =					model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(_UpperCAmelCase      ,							nn.Linear				)				)



		def 					A_		( self  :    str				)			->						Union[str, Any]:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																A         =					model_class(_UpperCAmelCase				)
																A         =					inspect.signature(model.forward				)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																A         =					[*signature.parameters.keys()]

																A         =					['''pixel_values''']
																self.assertListEqual(arg_names[:1]      ,							_UpperCAmelCase				)



		def 					A_		( self  :    Any				)			->						Optional[Any]:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCAmelCase				)



		def 					A_		( self  :    Dict				)			->						List[Any]:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase				)



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






									'''simple docstring'''

									for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																A         =					SwiftFormerModel.from_pretrained(_UpperCAmelCase				)
																self.assertIsNotNone(_UpperCAmelCase				)



		@unittest.skip(reason='SwiftFormer does not output attentions'				)
		def 					A_		( self  :    Optional[Any]				)			->						Optional[Any]:






									'''simple docstring'''

									pass



		def 					A_		( self  :    Optional[int]				)			->						Tuple:






									'''simple docstring'''

									def check_hidden_states_output(snake_case  :    Any      ,							snake_case  :    Any      ,							snake_case  :    Any				):
																A         =					model_class(_UpperCAmelCase				)
																model.to(_UpperCAmelCase				)
																model.eval()

																with torch.no_grad():
																							A         =					model(**self._prepare_for_class(_UpperCAmelCase      ,							_UpperCAmelCase				)				)

																A         =					outputs.hidden_states

																A         =					8
																self.assertEqual(len(_UpperCAmelCase				)      ,							_UpperCAmelCase				)  # TODO

																# SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
																# with the width and height being successively divided by 2, after every 2 blocks
																for i in range(len(_UpperCAmelCase				)				):
																							self.assertEqual(
																							    hidden_states[i].shape      ,							torch.Size(
																							        [
																							            self.model_tester.batch_size,
																							            self.model_tester.embed_dims[i // 2],
																							            (self.model_tester.image_size // 4) // 2 ** (i // 2),
																							            (self.model_tester.image_size // 4) // 2 ** (i // 2),
																							        ]				)      ,							)

									A         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																A         =					True
																check_hidden_states_output(_UpperCAmelCase      ,							_UpperCAmelCase      ,							_UpperCAmelCase				)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																A         =					True

																check_hidden_states_output(_UpperCAmelCase      ,							_UpperCAmelCase      ,							_UpperCAmelCase				)



		def 					A_		( self  :    List[str]				)			->						Tuple:






									'''simple docstring'''

									def _config_zero_init(snake_case  :    Optional[int]				):
																A         =					copy.deepcopy(_UpperCAmelCase				)
																for key in configs_no_init.__dict__.keys():
																							if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
																														setattr(_UpperCAmelCase      ,							_UpperCAmelCase      ,							1E-1_0				)
																							if isinstance(getattr(_UpperCAmelCase      ,							_UpperCAmelCase      ,							_UpperCAmelCase				)      ,							_UpperCAmelCase				):
																														A         =					_config_zero_init(getattr(_UpperCAmelCase      ,							_UpperCAmelCase				)				)
																														setattr(_UpperCAmelCase      ,							_UpperCAmelCase      ,							_UpperCAmelCase				)
																return configs_no_init

									A         =					self.model_tester.prepare_config_and_inputs_for_common()

									A         =					_config_zero_init(_UpperCAmelCase				)
									for model_class in self.all_model_classes:
																A         =					model_class(config=_UpperCAmelCase				)
																for name, param in model.named_parameters():
																							if param.requires_grad:
																														self.assertIn(
																														    ((param.data.mean() * 1E9) / 1E9).round().item()      ,							[0.0, 1.0]      ,							msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""      ,							)



		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'				)
		def 					A_		( self  :    Dict				)			->						List[str]:






									'''simple docstring'''

									pass



def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							A         =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
							return image






@require_torch
@require_vision
class      UpperCAmelCase__		(      unittest.TestCase     ):



		@cached_property
		def 					A_		( self  :    Dict				)			->						Optional[Any]:






									'''simple docstring'''

									return ViTImageProcessor.from_pretrained('MBZUAI/swiftformer-xs'				) if is_vision_available() else None



		@slow
		def 					A_		( self  :    List[Any]				)			->						str:






									'''simple docstring'''

									A         =					SwiftFormerForImageClassification.from_pretrained('MBZUAI/swiftformer-xs'				).to(_UpperCAmelCase				)

									A         =					self.default_image_processor
									A         =					prepare_img()
									A         =					image_processor(images=_UpperCAmelCase      ,							return_tensors='pt'				).to(_UpperCAmelCase				)

									# forward pass
									with torch.no_grad():
																A         =					model(**_UpperCAmelCase				)

									# verify the logits
									A         =					torch.Size((1, 1_000)				)
									self.assertEqual(outputs.logits.shape      ,							_UpperCAmelCase				)

									A         =					torch.tensor([[-2.1_7_0_3E0_0, 2.1_1_0_7E0_0, -2.0_8_1_1E0_0]]				).to(_UpperCAmelCase				)
									self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,							_UpperCAmelCase      ,							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_       :	int 							=     MODEL_FOR_MASKED_LM_MAPPING
		lowerCAmelCase_       :	Tuple 							=     TF_MODEL_FOR_MASKED_LM_MAPPING



		def 					A_		( self  :    Tuple				)			->						int:






									'''simple docstring'''

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

																torch.cuda.empty_cache()



		@require_tf
		def 					A_		( self  :    int				)			->						Optional[int]:






									'''simple docstring'''

									A         =					pipeline(task='fill-mask'      ,							model='sshleifer/tiny-distilroberta-base'      ,							top_k=2      ,							framework='tf'				)
									A         =					unmasker('My name is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {'sequence': 'My name is grouped', 'score': 2.1E-0_5, 'token': 38_015, 'token_str': ' grouped'},
									        {'sequence': 'My name is accuser', 'score': 2.1E-0_5, 'token': 25_506, 'token_str': ' accuser'},
									    ]      ,							)

									A         =					unmasker('The largest city in France is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {
									            'sequence': 'The largest city in France is grouped',
									            'score': 2.1E-0_5,
									            'token': 38_015,
									            'token_str': ' grouped',
									        },
									        {
									            'sequence': 'The largest city in France is accuser',
									            'score': 2.1E-0_5,
									            'token': 25_506,
									            'token_str': ' accuser',
									        },
									    ]      ,							)

									A         =					unmasker('My name is <mask>'      ,							targets=[' Patrick', ' Clara', ' Teven']      ,							top_k=3				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {'sequence': 'My name is Clara', 'score': 2E-0_5, 'token': 13_606, 'token_str': ' Clara'},
									        {'sequence': 'My name is Patrick', 'score': 2E-0_5, 'token': 3_499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 1.9E-0_5, 'token': 2_941, 'token_str': ' Te'},
									    ]      ,							)



		@require_torch
		def 					A_		( self  :    str				)			->						int:






									'''simple docstring'''

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

									A         =					unmasker('My name is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {'sequence': 'My name is Maul', 'score': 2.2E-0_5, 'token': 35_676, 'token_str': ' Maul'},
									        {'sequence': 'My name isELS', 'score': 2.2E-0_5, 'token': 16_416, 'token_str': 'ELS'},
									    ]      ,							)

									A         =					unmasker('The largest city in France is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {
									            'sequence': 'The largest city in France is Maul',
									            'score': 2.2E-0_5,
									            'token': 35_676,
									            'token_str': ' Maul',
									        },
									        {'sequence': 'The largest city in France isELS', 'score': 2.2E-0_5, 'token': 16_416, 'token_str': 'ELS'},
									    ]      ,							)

									A         =					unmasker('My name is <mask>'      ,							targets=[' Patrick', ' Clara', ' Teven']      ,							top_k=3				)
									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        {'sequence': 'My name is Patrick', 'score': 2.1E-0_5, 'token': 3_499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Te', 'score': 2E-0_5, 'token': 2_941, 'token_str': ' Te'},
									        {'sequence': 'My name is Clara', 'score': 2E-0_5, 'token': 13_606, 'token_str': ' Clara'},
									    ]      ,							)

									A         =					unmasker('My name is <mask> <mask>'      ,							top_k=2				)

									self.assertEqual(
									    nested_simplify(snake_case      ,							decimals=6				)      ,							[
									        [
									            {
									                'score': 2.2E-0_5,
									                'token': 35_676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is Maul<mask></s>',
									            },
									            {'score': 2.2E-0_5, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
									        ],
									        [
									            {
									                'score': 2.2E-0_5,
									                'token': 35_676,
									                'token_str': ' Maul',
									                'sequence': '<s>My name is<mask> Maul</s>',
									            },
									            {'score': 2.2E-0_5, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
									        ],
									    ]      ,							)



		@require_torch_gpu
		def 					A_		( self  :    Tuple				)			->						List[str]:






									'''simple docstring'''

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

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

									A         =					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(snake_case      ,							snake_case				)



		@slow
		@require_torch
		def 					A_		( self  :    List[Any]				)			->						int:






									'''simple docstring'''

									A         =					pipeline(task='fill-mask'      ,							model='distilroberta-base'      ,							top_k=2      ,							framework='pt'				)
									self.run_large_test(snake_case				)



		@slow
		@require_tf
		def 					A_		( self  :    Tuple				)			->						Optional[int]:






									'''simple docstring'''

									A         =					pipeline(task='fill-mask'      ,							model='distilroberta-base'      ,							top_k=2      ,							framework='tf'				)
									self.run_large_test(snake_case				)



		def 					A_		( self  :    Dict      ,							snake_case  :    List[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					unmasker('My name is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case				)      ,							[
									        {'sequence': 'My name is John', 'score': 0.008, 'token': 610, 'token_str': ' John'},
									        {'sequence': 'My name is Chris', 'score': 0.007, 'token': 1_573, 'token_str': ' Chris'},
									    ]      ,							)
									A         =					unmasker('The largest city in France is <mask>'				)
									self.assertEqual(
									    nested_simplify(snake_case				)      ,							[
									        {
									            'sequence': 'The largest city in France is Paris',
									            'score': 0.251,
									            'token': 2_201,
									            'token_str': ' Paris',
									        },
									        {
									            'sequence': 'The largest city in France is Lyon',
									            'score': 0.214,
									            'token': 12_790,
									            'token_str': ' Lyon',
									        },
									    ]      ,							)

									A         =					unmasker('My name is <mask>'      ,							targets=[' Patrick', ' Clara', ' Teven']      ,							top_k=3				)
									self.assertEqual(
									    nested_simplify(snake_case				)      ,							[
									        {'sequence': 'My name is Patrick', 'score': 0.005, 'token': 3_499, 'token_str': ' Patrick'},
									        {'sequence': 'My name is Clara', 'score': 0.000, 'token': 13_606, 'token_str': ' Clara'},
									        {'sequence': 'My name is Te', 'score': 0.000, 'token': 2_941, 'token_str': ' Te'},
									    ]      ,							)



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






									'''simple docstring'''

									A         =					pipeline(task='fill-mask'      ,							model='sshleifer/tiny-distilroberta-base'      ,							framework='pt'				)
									A         =					None
									A         =					None
									self.run_pipeline_test(snake_case      ,							[]				)



		@require_tf
		def 					A_		( self  :    Tuple				)			->						Dict:






									'''simple docstring'''

									A         =					pipeline(task='fill-mask'      ,							model='sshleifer/tiny-distilroberta-base'      ,							framework='tf'				)
									A         =					None
									A         =					None
									self.run_pipeline_test(snake_case      ,							[]				)



		def 					A_		( self  :    str      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    Optional[int]      ,							snake_case  :    Optional[Any]				)			->						Union[str, Any]:






									'''simple docstring'''

									if tokenizer is None or tokenizer.mask_token_id is None:
																self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'				)

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



		def 					A_		( self  :    Any      ,							snake_case  :    Any      ,							snake_case  :    Optional[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					fill_masker.tokenizer
									A         =					fill_masker.model

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

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

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

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

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



		def 					A_		( self  :    str      ,							snake_case  :    Any      ,							snake_case  :    Optional[int]				)			->						str:






									'''simple docstring'''

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

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

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

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



		def 					A_		( self  :    Any      ,							snake_case  :    Optional[Any]      ,							snake_case  :    int				)			->						List[Any]:






									'''simple docstring'''

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

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



		def 					A_		( self  :    str      ,							snake_case  :    List[str]      ,							snake_case  :    Dict				)			->						Tuple:






									'''simple docstring'''

									A         =					tokenizer.get_vocab()
									A         =					FillMaskPipeline(model=snake_case      ,							tokenizer=snake_case				)

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

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



		def 					A_		( self  :    Union[str, Any]      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    Dict				)			->						int:






									'''simple docstring'''

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

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



		def 					A_		( self  :    str      ,							snake_case  :    List[Any]      ,							snake_case  :    Union[str, Any]				)			->						Union[str, Any]:






									'''simple docstring'''

									A         =					FillMaskPipeline(model=snake_case      ,							tokenizer=snake_case				)

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



