



import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class       a							(			__lowerCamelCase  ,							unittest.TestCase				):
		__lowerCAmelCase	:    Optional[Any]											=					UnCLIPImageVariationPipeline
		__lowerCAmelCase	:    Optional[Any]											=					IMAGE_VARIATION_PARAMS - {"""height""", """width""", """guidance_scale"""}
		__lowerCAmelCase	:    Tuple											=					IMAGE_VARIATION_BATCH_PARAMS

		__lowerCAmelCase	:    Optional[int]											=					[
		    """generator""",
		    """return_dict""",
		    """decoder_num_inference_steps""",
		    """super_res_num_inference_steps""",
		]
		__lowerCAmelCase	:    Any											=					False



		@property
		def 	__lowerCamelCase			(     self     :Optional[int]  ):
						return 3_2



		@property
		def 	__lowerCamelCase			(     self     :List[Any]  ):
						return 3_2



		@property
		def 	__lowerCamelCase			(     self     :List[str]  ):
						return self.time_input_dim



		@property
		def 	__lowerCamelCase			(     self     :List[str]  ):
						return self.time_input_dim * 4



		@property
		def 	__lowerCamelCase			(     self     :List[str]  ):
						return 1_0_0



		@property
		def 	__lowerCamelCase			(     self     :Tuple  ):
						snake_case__	:      str     		=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )
						return tokenizer



		@property
		def 	__lowerCamelCase			(     self     :Any  ):
						torch.manual_seed(0  )
						snake_case__	:      List[str]     		=	CLIPTextConfig(
						    bos_token_id=0   ,eos_token_id=2   ,hidden_size=self.text_embedder_hidden_size   ,projection_dim=self.text_embedder_hidden_size   ,intermediate_size=3_7   ,layer_norm_eps=1e-0_5   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_0_0_0   ,)
						return CLIPTextModelWithProjection(__lowercase  )



		@property
		def 	__lowerCamelCase			(     self     :Dict  ):
						torch.manual_seed(0  )
						snake_case__	:      List[str]     		=	CLIPVisionConfig(
						    hidden_size=self.text_embedder_hidden_size   ,projection_dim=self.text_embedder_hidden_size   ,num_hidden_layers=5   ,num_attention_heads=4   ,image_size=3_2   ,intermediate_size=3_7   ,patch_size=1   ,)
						return CLIPVisionModelWithProjection(__lowercase  )



		@property
		def 	__lowerCamelCase			(     self     :str  ):
						torch.manual_seed(0  )

						snake_case__	:      List[str]     		=	{
						    '''clip_embeddings_dim''': self.text_embedder_hidden_size,
						    '''time_embed_dim''': self.time_embed_dim,
						    '''cross_attention_dim''': self.cross_attention_dim,
						}

						snake_case__	:      Any     		=	UnCLIPTextProjModel(**__lowercase  )
						return model



		@property
		def 	__lowerCamelCase			(     self     :Union[str, Any]  ):
						torch.manual_seed(0  )

						snake_case__	:      Any     		=	{
						    '''sample_size''': 3_2,
						    # RGB in channels
						    '''in_channels''': 3,
						    # Out channels is double in channels because predicts mean and variance
						    '''out_channels''': 6,
						    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
						    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
						    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
						    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
						    '''layers_per_block''': 1,
						    '''cross_attention_dim''': self.cross_attention_dim,
						    '''attention_head_dim''': 4,
						    '''resnet_time_scale_shift''': '''scale_shift''',
						    '''class_embed_type''': '''identity''',
						}

						snake_case__	:      int     		=	UNetaDConditionModel(**__lowercase  )
						return model



		@property
		def 	__lowerCamelCase			(     self     :List[str]  ):
						return {
						    "sample_size": 6_4,
						    "layers_per_block": 1,
						    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
						    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
						    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
						    "in_channels": 6,
						    "out_channels": 3,
						}



		@property
		def 	__lowerCamelCase			(     self     :str  ):
						torch.manual_seed(0  )

						snake_case__	:      Dict     		=	UNetaDModel(**self.dummy_super_res_kwargs  )
						return model



		@property
		def 	__lowerCamelCase			(     self     :Tuple  ):
						# seeded differently to get different unet than `self.dummy_super_res_first`
						torch.manual_seed(1  )

						snake_case__	:      str     		=	UNetaDModel(**self.dummy_super_res_kwargs  )
						return model



		def 	__lowerCamelCase			(     self     :List[str]  ):
						snake_case__	:      Dict     		=	self.dummy_decoder
						snake_case__	:      List[str]     		=	self.dummy_text_proj
						snake_case__	:      List[str]     		=	self.dummy_text_encoder
						snake_case__	:      Optional[Any]     		=	self.dummy_tokenizer
						snake_case__	:      List[str]     		=	self.dummy_super_res_first
						snake_case__	:      str     		=	self.dummy_super_res_last

						snake_case__	:      Optional[int]     		=	UnCLIPScheduler(
						    variance_type='''learned_range'''   ,prediction_type='''epsilon'''   ,num_train_timesteps=1_0_0_0   ,)

						snake_case__	:      Dict     		=	UnCLIPScheduler(
						    variance_type='''fixed_small_log'''   ,prediction_type='''epsilon'''   ,num_train_timesteps=1_0_0_0   ,)

						snake_case__	:      str     		=	CLIPImageProcessor(crop_size=3_2   ,size=3_2  )

						snake_case__	:      Optional[Any]     		=	self.dummy_image_encoder

						return {
						    "decoder": decoder,
						    "text_encoder": text_encoder,
						    "tokenizer": tokenizer,
						    "text_proj": text_proj,
						    "feature_extractor": feature_extractor,
						    "image_encoder": image_encoder,
						    "super_res_first": super_res_first,
						    "super_res_last": super_res_last,
						    "decoder_scheduler": decoder_scheduler,
						    "super_res_scheduler": super_res_scheduler,
						}



		def 	__lowerCamelCase			(     self     :Optional[int]   ,__lowercase     :List[Any]   ,__lowercase     :int=0   ,__lowercase     :Union[str, Any]=True  ):
						snake_case__	:      Optional[Any]     		=	floats_tensor((1, 3, 3_2, 3_2)   ,rng=random.Random(__lowercase  )  ).to(__lowercase  )
						if str(__lowercase  ).startswith('''mps'''  ):
										snake_case__	:      Optional[int]     		=	torch.manual_seed(__lowercase  )
						else:
										snake_case__	:      List[str]     		=	torch.Generator(device=__lowercase  ).manual_seed(__lowercase  )

						if pil_image:
										snake_case__	:      str     		=	input_image * 0.5 + 0.5
										snake_case__	:      Tuple     		=	input_image.clamp(0   ,1  )
										snake_case__	:      Dict     		=	input_image.cpu().permute(0   ,2   ,3   ,1  ).float().numpy()
										snake_case__	:      Optional[Any]     		=	DiffusionPipeline.numpy_to_pil(__lowercase  )[0]

						return {
						    "image": input_image,
						    "generator": generator,
						    "decoder_num_inference_steps": 2,
						    "super_res_num_inference_steps": 2,
						    "output_type": "np",
						}



		def 	__lowerCamelCase			(     self     :Union[str, Any]  ):
						snake_case__	:      Union[str, Any]     		=	'''cpu'''

						snake_case__	:      Tuple     		=	self.get_dummy_components()

						snake_case__	:      Optional[int]     		=	self.pipeline_class(**__lowercase  )
						snake_case__	:      List[str]     		=	pipe.to(__lowercase  )

						pipe.set_progress_bar_config(disable=__lowercase  )

						snake_case__	:      str     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )

						snake_case__	:      List[str]     		=	pipe(**__lowercase  )
						snake_case__	:      Optional[int]     		=	output.images

						snake_case__	:      Union[str, Any]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )

						snake_case__	:      str     		=	pipe(
						    **__lowercase   ,return_dict=__lowercase   ,)[0]

						snake_case__	:      Union[str, Any]     		=	image[0, -3:, -3:, -1]
						snake_case__	:      Any     		=	image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)

						snake_case__	:      Optional[Any]     		=	np.array(
						    [
						        0.9997,
						        0.0002,
						        0.9997,
						        0.9997,
						        0.9969,
						        0.0023,
						        0.9997,
						        0.9969,
						        0.9970,
						    ]  )

						assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2



		def 	__lowerCamelCase			(     self     :int  ):
						snake_case__	:      Dict     		=	'''cpu'''

						snake_case__	:      int     		=	self.get_dummy_components()

						snake_case__	:      int     		=	self.pipeline_class(**__lowercase  )
						snake_case__	:      Any     		=	pipe.to(__lowercase  )

						pipe.set_progress_bar_config(disable=__lowercase  )

						snake_case__	:      Optional[int]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )

						snake_case__	:      Tuple     		=	pipe(**__lowercase  )
						snake_case__	:      Union[str, Any]     		=	output.images

						snake_case__	:      List[str]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )

						snake_case__	:      str     		=	pipe(
						    **__lowercase   ,return_dict=__lowercase   ,)[0]

						snake_case__	:      Optional[Any]     		=	image[0, -3:, -3:, -1]
						snake_case__	:      str     		=	image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)

						snake_case__	:      Union[str, Any]     		=	np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]  )

						assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2



		def 	__lowerCamelCase			(     self     :str  ):
						snake_case__	:      Optional[int]     		=	'''cpu'''

						snake_case__	:      Optional[Any]     		=	self.get_dummy_components()

						snake_case__	:      Tuple     		=	self.pipeline_class(**__lowercase  )
						snake_case__	:      Any     		=	pipe.to(__lowercase  )

						pipe.set_progress_bar_config(disable=__lowercase  )

						snake_case__	:      int     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )
						snake_case__	:      List[str]     		=	[
						    pipeline_inputs['''image'''],
						    pipeline_inputs['''image'''],
						]

						snake_case__	:      Tuple     		=	pipe(**__lowercase  )
						snake_case__	:      Dict     		=	output.images

						snake_case__	:      List[str]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )
						snake_case__	:      int     		=	[
						    tuple_pipeline_inputs['''image'''],
						    tuple_pipeline_inputs['''image'''],
						]

						snake_case__	:      int     		=	pipe(
						    **__lowercase   ,return_dict=__lowercase   ,)[0]

						snake_case__	:      Union[str, Any]     		=	image[0, -3:, -3:, -1]
						snake_case__	:      List[Any]     		=	image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (2, 6_4, 6_4, 3)

						snake_case__	:      List[str]     		=	np.array(
						    [
						        0.9997,
						        0.9989,
						        0.0008,
						        0.0021,
						        0.9960,
						        0.0018,
						        0.0014,
						        0.0002,
						        0.9933,
						    ]  )

						assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2



		def 	__lowerCamelCase			(     self     :Optional[Any]  ):
						snake_case__	:      Optional[int]     		=	torch.device('''cpu'''  )


						class       a							:
								__lowerCAmelCase	:    Union[str, Any]											=					1

						snake_case__	:      int     		=	self.get_dummy_components()

						snake_case__	:      Tuple     		=	self.pipeline_class(**__lowercase  )
						snake_case__	:      Optional[int]     		=	pipe.to(__lowercase  )

						pipe.set_progress_bar_config(disable=__lowercase  )

						snake_case__	:      Union[str, Any]     		=	torch.Generator(device=__lowercase  ).manual_seed(0  )
						snake_case__	:      int     		=	pipe.decoder.dtype
						snake_case__	:      List[str]     		=	1

						snake_case__	:      Union[str, Any]     		=	(
						    batch_size,
						    pipe.decoder.config.in_channels,
						    pipe.decoder.config.sample_size,
						    pipe.decoder.config.sample_size,
						)
						snake_case__	:      int     		=	pipe.prepare_latents(
						    __lowercase   ,dtype=__lowercase   ,device=__lowercase   ,generator=__lowercase   ,latents=__lowercase   ,scheduler=DummyScheduler()  )

						snake_case__	:      List[str]     		=	(
						    batch_size,
						    pipe.super_res_first.config.in_channels // 2,
						    pipe.super_res_first.config.sample_size,
						    pipe.super_res_first.config.sample_size,
						)
						snake_case__	:      Union[str, Any]     		=	pipe.prepare_latents(
						    __lowercase   ,dtype=__lowercase   ,device=__lowercase   ,generator=__lowercase   ,latents=__lowercase   ,scheduler=DummyScheduler()  )

						snake_case__	:      List[Any]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )

						snake_case__	:      Dict     		=	pipe(
						    **__lowercase   ,decoder_latents=__lowercase   ,super_res_latents=__lowercase  ).images

						snake_case__	:      Union[str, Any]     		=	self.get_dummy_inputs(__lowercase   ,pil_image=__lowercase  )
						# Don't pass image, instead pass embedding
						snake_case__	:      int     		=	pipeline_inputs.pop('''image'''  )
						snake_case__	:      List[Any]     		=	pipe.image_encoder(__lowercase  ).image_embeds

						snake_case__	:      List[str]     		=	pipe(
						    **__lowercase   ,decoder_latents=__lowercase   ,super_res_latents=__lowercase   ,image_embeddings=__lowercase   ,).images

						# make sure passing text embeddings manually is identical
						assert np.abs(img_out_a - img_out_a  ).max() < 1e-4



		@skip_mps
		def 	__lowerCamelCase			(     self     :Dict  ):
						snake_case__	:      Any     		=	torch_device == '''cpu'''

						# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
						snake_case__	:      Dict     		=	1e-2

						self._test_attention_slicing_forward_pass(
						    test_max_difference=__lowercase   ,expected_max_diff=__lowercase  )



		@skip_mps
		def 	__lowerCamelCase			(     self     :str  ):
						snake_case__	:      Optional[Any]     		=	torch_device == '''cpu'''
						snake_case__	:      List[str]     		=	True
						snake_case__	:      Optional[int]     		=	[
						    '''decoder_num_inference_steps''',
						    '''super_res_num_inference_steps''',
						]

						self._test_inference_batch_single_identical(
						    test_max_difference=__lowercase   ,relax_max_difference=__lowercase   ,additional_params_copy_to_batched_inputs=__lowercase   ,)



		def 	__lowerCamelCase			(     self     :Optional[int]  ):
						snake_case__	:      Any     		=	[
						    '''decoder_num_inference_steps''',
						    '''super_res_num_inference_steps''',
						]

						if torch_device == "mps":
										# TODO: MPS errors with larger batch sizes
										snake_case__	:      Dict     		=	[2, 3]
										self._test_inference_batch_consistent(
										    batch_sizes=__lowercase   ,additional_params_copy_to_batched_inputs=__lowercase   ,)
						else:
										self._test_inference_batch_consistent(
										    additional_params_copy_to_batched_inputs=__lowercase  )



		@skip_mps
		def 	__lowerCamelCase			(     self     :Tuple  ):
						return super().test_dict_tuple_outputs_equivalent()



		@skip_mps
		def 	__lowerCamelCase			(     self     :str  ):
						return super().test_save_load_local()






		@skip_mps
		def 	__lowerCamelCase			(     self     :List[Any]  ):
						return super().test_save_load_optional_components()


@slow
@require_torch_gpu
class       a							(			unittest.TestCase				):



		def 	__lowerCamelCase			(     self     :int  ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()






		def 	__lowerCamelCase			(     self     :Union[str, Any]  ):
						snake_case__	:      List[str]     		=	load_image(
						    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''  )
						snake_case__	:      Optional[Any]     		=	load_numpy(
						    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
						    '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''  )

						snake_case__	:      Tuple     		=	UnCLIPImageVariationPipeline.from_pretrained(
						    '''kakaobrain/karlo-v1-alpha-image-variations'''   ,torch_dtype=torch.floataa  )
						snake_case__	:      Optional[int]     		=	pipeline.to(__lowercase  )
						pipeline.set_progress_bar_config(disable=__lowercase  )

						snake_case__	:      Dict     		=	torch.Generator(device='''cpu'''  ).manual_seed(0  )
						snake_case__	:      List[str]     		=	pipeline(
						    __lowercase   ,generator=__lowercase   ,output_type='''np'''   ,)

						snake_case__	:      str     		=	output.images[0]

						assert image.shape == (2_5_6, 2_5_6, 3)

						assert_mean_pixel_difference(__lowercase   ,__lowercase   ,1_5  )






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       a							(			unittest.TestCase				):
		__lowerCAmelCase	:    Any											=					MODEL_FOR_MASKED_LM_MAPPING
		__lowerCAmelCase	:    Optional[Any]											=					TF_MODEL_FOR_MASKED_LM_MAPPING



		def 	__lowerCamelCase			(     self     :str  ):
						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 	__lowerCamelCase			(     self     :Any  ):
						snake_case__	:      Optional[Any]     		=	pipeline(task='''fill-mask'''   ,model='''sshleifer/tiny-distilroberta-base'''   ,top_k=2   ,framework='''tf'''  )
						snake_case__	:      int     		=	unmasker('''My name is <mask>'''  )
						self.assertEqual(
						    nested_simplify(__lowercase   ,decimals=6  )   ,[
						        {'''sequence''': '''My name is grouped''', '''score''': 2.1e-0_5, '''token''': 3_8_0_1_5, '''token_str''': ''' grouped'''},
						        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-0_5, '''token''': 2_5_5_0_6, '''token_str''': ''' accuser'''},
						    ]   ,)

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

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



		@require_torch
		def 	__lowerCamelCase			(     self     :Optional[int]  ):
						snake_case__	:      str     		=	pipeline(task='''fill-mask'''   ,model='''sshleifer/tiny-distilroberta-base'''   ,top_k=2   ,framework='''pt'''  )

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

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

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

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

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



		@require_torch_gpu
		def 	__lowerCamelCase			(     self     :int  ):
						snake_case__	:      Optional[int]     		=	pipeline('''fill-mask'''   ,model='''hf-internal-testing/tiny-random-distilbert'''   ,device=0   ,framework='''pt'''  )

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

						snake_case__	:      List[str]     		=	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(__lowercase   ,__lowercase  )



		@slow
		@require_torch
		def 	__lowerCamelCase			(     self     :str  ):
						snake_case__	:      List[str]     		=	pipeline(task='''fill-mask'''   ,model='''distilroberta-base'''   ,top_k=2   ,framework='''pt'''  )
						self.run_large_test(__lowercase  )



		@slow
		@require_tf
		def 	__lowerCamelCase			(     self     :Any  ):
						snake_case__	:      Optional[Any]     		=	pipeline(task='''fill-mask'''   ,model='''distilroberta-base'''   ,top_k=2   ,framework='''tf'''  )
						self.run_large_test(__lowercase  )



		def 	__lowerCamelCase			(     self     :Optional[Any]   ,__lowercase     :List[Any]  ):
						snake_case__	:      Optional[Any]     		=	unmasker('''My name is <mask>'''  )
						self.assertEqual(
						    nested_simplify(__lowercase  )   ,[
						        {'''sequence''': '''My name is John''', '''score''': 0.008, '''token''': 6_1_0, '''token_str''': ''' John'''},
						        {'''sequence''': '''My name is Chris''', '''score''': 0.007, '''token''': 1_5_7_3, '''token_str''': ''' Chris'''},
						    ]   ,)
						snake_case__	:      str     		=	unmasker('''The largest city in France is <mask>'''  )
						self.assertEqual(
						    nested_simplify(__lowercase  )   ,[
						        {
						            '''sequence''': '''The largest city in France is Paris''',
						            '''score''': 0.251,
						            '''token''': 2_2_0_1,
						            '''token_str''': ''' Paris''',
						        },
						        {
						            '''sequence''': '''The largest city in France is Lyon''',
						            '''score''': 0.214,
						            '''token''': 1_2_7_9_0,
						            '''token_str''': ''' Lyon''',
						        },
						    ]   ,)

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



		@require_torch
		def 	__lowerCamelCase			(     self     :List[str]  ):
						snake_case__	:      List[Any]     		=	pipeline(task='''fill-mask'''   ,model='''sshleifer/tiny-distilroberta-base'''   ,framework='''pt'''  )
						snake_case__	:      str     		=	None
						snake_case__	:      int     		=	None
						self.run_pipeline_test(__lowercase   ,[]  )



		@require_tf
		def 	__lowerCamelCase			(     self     :int  ):
						snake_case__	:      Optional[int]     		=	pipeline(task='''fill-mask'''   ,model='''sshleifer/tiny-distilroberta-base'''   ,framework='''tf'''  )
						snake_case__	:      int     		=	None
						snake_case__	:      List[str]     		=	None
						self.run_pipeline_test(__lowercase   ,[]  )



		def 	__lowerCamelCase			(     self     :Any   ,__lowercase     :Any   ,__lowercase     :str   ,__lowercase     :Union[str, Any]  ):
						if tokenizer is None or tokenizer.mask_token_id is None:
										self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)'''  )

						snake_case__	:      Optional[int]     		=	FillMaskPipeline(model=__lowercase   ,tokenizer=__lowercase  )
						snake_case__	:      List[str]     		=	[
						    F"""This is another {tokenizer.mask_token} test""",
						]
						return fill_masker, examples



		def 	__lowerCamelCase			(     self     :Optional[Any]   ,__lowercase     :List[Any]   ,__lowercase     :Optional[Any]  ):
						snake_case__	:      List[str]     		=	fill_masker.tokenizer
						snake_case__	:      List[Any]     		=	fill_masker.model

						snake_case__	:      Dict     		=	fill_masker(
						    F"""This is a {tokenizer.mask_token}"""   ,)
						self.assertEqual(
						    __lowercase   ,[
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						    ]   ,)

						snake_case__	:      Tuple     		=	fill_masker([F"""This is a {tokenizer.mask_token}"""]  )
						self.assertEqual(
						    __lowercase   ,[
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						    ]   ,)

						snake_case__	:      List[str]     		=	fill_masker([F"""This is a {tokenizer.mask_token}""", F"""Another {tokenizer.mask_token} great test."""]  )
						self.assertEqual(
						    __lowercase   ,[
						        [
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        ],
						        [
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        ],
						    ]   ,)

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

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



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

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

						# Score equivalence
						snake_case__	:      Dict     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""   ,targets=__lowercase  )
						snake_case__	:      Union[str, Any]     		=	[top_mask['''token_str'''] for top_mask in outputs]
						snake_case__	:      Tuple     		=	[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(__lowercase  ) == set(__lowercase  ):
										snake_case__	:      List[Any]     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""   ,targets=__lowercase  )
										snake_case__	:      int     		=	[top_mask['''score'''] for top_mask in unmasked_targets]
										self.assertEqual(nested_simplify(__lowercase  )   ,nested_simplify(__lowercase  )  )

						# Raises with invalid
						with self.assertRaises(__lowercase  ):
										snake_case__	:      List[str]     		=	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(__lowercase  ):
														snake_case__	:      List[Any]     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""   ,targets=['''''']  )
										with self.assertRaises(__lowercase  ):
														snake_case__	:      Optional[int]     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""   ,targets=''''''  )



		def 	__lowerCamelCase			(     self     :Any   ,__lowercase     :Union[str, Any]   ,__lowercase     :Dict  ):
						snake_case__	:      int     		=	FillMaskPipeline(model=__lowercase   ,tokenizer=__lowercase   ,top_k=2  )
						snake_case__	:      Tuple     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""  )
						self.assertEqual(
						    __lowercase   ,[
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						    ]   ,)

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



		def 	__lowerCamelCase			(     self     :List[Any]   ,__lowercase     :Tuple   ,__lowercase     :str  ):
						snake_case__	:      Optional[int]     		=	tokenizer.get_vocab()
						snake_case__	:      int     		=	FillMaskPipeline(model=__lowercase   ,tokenizer=__lowercase  )

						# top_k=2, ntargets=3
						snake_case__	:      int     		=	sorted(vocab.keys()  )[:3]
						snake_case__	:      List[Any]     		=	fill_masker(F"""This is a {tokenizer.mask_token}"""   ,top_k=2   ,targets=__lowercase  )

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



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :Dict   ,__lowercase     :Dict  ):
						snake_case__	:      Union[str, Any]     		=	FillMaskPipeline(model=__lowercase   ,tokenizer=__lowercase  )
						snake_case__	:      str     		=	tokenizer.get_vocab()
						# String duplicates + id duplicates
						snake_case__	:      int     		=	sorted(vocab.keys()  )[:3]
						snake_case__	:      Optional[Any]     		=	[targets[0], targets[1], targets[0], targets[2], targets[1]]
						snake_case__	:      Optional[Any]     		=	fill_masker(F"""My name is {tokenizer.mask_token}"""   ,targets=__lowercase   ,top_k=1_0  )

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






		def 	__lowerCamelCase			(     self     :Optional[Any]   ,__lowercase     :List[Any]   ,__lowercase     :Optional[Any]  ):
						snake_case__	:      Any     		=	FillMaskPipeline(model=__lowercase   ,tokenizer=__lowercase  )

						snake_case__	:      Tuple     		=	fill_masker(
						    F"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"""   ,top_k=2  )
						self.assertEqual(
						    __lowercase   ,[
						        [
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        ],
						        [
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        ],
						        [
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						            {'''sequence''': ANY(__lowercase  ), '''score''': ANY(__lowercase  ), '''token''': ANY(__lowercase  ), '''token_str''': ANY(__lowercase  )},
						        ],
						    ]   ,)

