

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 	__magic_name__    (			unittest.TestCase      ):
			SCREAMING_SNAKE_CASE							   =						MODEL_FOR_MASKED_LM_MAPPING
			SCREAMING_SNAKE_CASE							   =						TF_MODEL_FOR_MASKED_LM_MAPPING





			def 		__magic_name__    (		self					)   -> Tuple:




						'''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 		__magic_name__    (		self					)   -> List[Any]:




						'''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-05, 'token': 3_8015, 'token_str': ' grouped'},
						        {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 2_5506, '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-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        =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-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 		__magic_name__    (		self					)   -> Dict:




						'''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-05, 'token': 3_5676, 'token_str': ' Maul'},
						        {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 1_6416, '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-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        =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-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        =unmasker('My name is <mask> <mask>'					,  top_k=2					)

						self.assertEqual(
						    nested_simplify(__snake_case					,  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 		__magic_name__    (		self					)   -> Optional[Any]:




						'''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 		__magic_name__    (		self					)   -> Union[str, Any]:




						'''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 		__magic_name__    (		self					)   -> Optional[Any]:




						'''simple docstring'''
						__a        =pipeline(task='fill-mask'					,  model='distilroberta-base'					,  top_k=2					,  framework='tf'					)
						self.run_large_test(__snake_case					)





			def 		__magic_name__    (		self					,  __snake_case					)   -> str:




						'''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': 1573, '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': 2201,
						            'token_str': ' Paris',
						        },
						        {
						            'sequence': 'The largest city in France is Lyon',
						            'score': 0.214,
						            'token': 1_2790,
						            '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': 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 		__magic_name__    (		self					)   -> Optional[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 		__magic_name__    (		self					)   -> str:




						'''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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					,  __snake_case					)   -> 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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> 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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> Tuple:




						'''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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> int:




						'''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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> Any:




						'''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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> Any:




						'''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 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> 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					)},
						        ],
						    ]					,  )









import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device


_lowerCAmelCase					:			Optional[Any]  				=			False






class 	__magic_name__    (			unittest.TestCase      ):
			pass






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





			def 		__magic_name__    (		self					)   -> Optional[int]:




						'''simple docstring'''
						__a        =VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion'					)
						pipe.to(__snake_case					)
						pipe.set_progress_bar_config(disable=__snake_case					)

						__a        =load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'					)
						__a        =torch.manual_seed(0					)
						__a        =pipe(
						    image=__snake_case					,  generator=__snake_case					,  guidance_scale=7.5					,  num_inference_steps=50					,  output_type='numpy'					,  ).images

						__a        =image[0, 253:256, 253:256, -1]

						assert image.shape == (1, 512, 512, 3)
						__a        =np.array([0.0441, 0.0469, 0.0507, 0.0575, 0.0632, 0.0650, 0.0865, 0.0909, 0.0945]					)

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






