
"""simple docstring"""




import shutil
import tempfile
import unittest

from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torchaudio

from .test_feature_extraction_clap import floats_list







@require_torchaudio
@require_sentencepiece
class     lowercase(unittest.TestCase       ):



     def 			lowercase__  (							self   )		->     List[str]:







         """simple docstring"""



         a__		=			'laion/clap-htsat-unfused'
         a__		=			tempfile.mkdtemp()



     def 			lowercase__  (							self     ,				**__SCREAMING_SNAKE_CASE   )		->     Optional[Any]:







         """simple docstring"""



         return RobertaTokenizer.from_pretrained(self.checkpoint     ,				**__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self     ,				**__SCREAMING_SNAKE_CASE   )		->     Tuple:







         """simple docstring"""



         return ClapFeatureExtractor.from_pretrained(self.checkpoint     ,				**__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         shutil.rmtree(self.tmpdirname   )



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







         """simple docstring"""



         a__		=			self.get_tokenizer()
         a__		=			self.get_feature_extractor()

         a__		=			ClapProcessor(tokenizer=__SCREAMING_SNAKE_CASE     ,				feature_extractor=__SCREAMING_SNAKE_CASE   )

         processor.save_pretrained(self.tmpdirname   )
         a__		=			ClapProcessor.from_pretrained(self.tmpdirname   )

         self.assertEqual(processor.tokenizer.get_vocab()     ,				tokenizer.get_vocab()   )
         self.assertIsInstance(processor.tokenizer     ,				__SCREAMING_SNAKE_CASE   )

         self.assertEqual(processor.feature_extractor.to_json_string()     ,				feature_extractor.to_json_string()   )
         self.assertIsInstance(processor.feature_extractor     ,				__SCREAMING_SNAKE_CASE   )



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







         """simple docstring"""



         a__		=			ClapProcessor(tokenizer=self.get_tokenizer()     ,				feature_extractor=self.get_feature_extractor()   )
         processor.save_pretrained(self.tmpdirname   )

         a__		=			self.get_tokenizer(bos_token='(BOS)'     ,				eos_token='(EOS)'   )
         a__		=			self.get_feature_extractor(do_normalize=__SCREAMING_SNAKE_CASE     ,				padding_value=1.0   )

         a__		=			ClapProcessor.from_pretrained(
             self.tmpdirname     ,				bos_token='(BOS)'     ,				eos_token='(EOS)'     ,				do_normalize=__SCREAMING_SNAKE_CASE     ,				padding_value=1.0   )

         self.assertEqual(processor.tokenizer.get_vocab()     ,				tokenizer_add_kwargs.get_vocab()   )
         self.assertIsInstance(processor.tokenizer     ,				__SCREAMING_SNAKE_CASE   )

         self.assertEqual(processor.feature_extractor.to_json_string()     ,				feature_extractor_add_kwargs.to_json_string()   )
         self.assertIsInstance(processor.feature_extractor     ,				__SCREAMING_SNAKE_CASE   )



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







         """simple docstring"""



         a__		=			self.get_feature_extractor()
         a__		=			self.get_tokenizer()

         a__		=			ClapProcessor(tokenizer=__SCREAMING_SNAKE_CASE     ,				feature_extractor=__SCREAMING_SNAKE_CASE   )

         a__		=			floats_list((3, 1_0_0_0)   )

         a__		=			feature_extractor(__SCREAMING_SNAKE_CASE     ,				return_tensors='np'   )
         a__		=			processor(audios=__SCREAMING_SNAKE_CASE     ,				return_tensors='np'   )

         for key in input_feat_extract.keys():
             self.assertAlmostEqual(input_feat_extract[key].sum()     ,				input_processor[key].sum()     ,				delta=1e-2   )



     def 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         a__		=			self.get_feature_extractor()
         a__		=			self.get_tokenizer()

         a__		=			ClapProcessor(tokenizer=__SCREAMING_SNAKE_CASE     ,				feature_extractor=__SCREAMING_SNAKE_CASE   )

         a__		=			'This is a test string'

         a__		=			processor(text=__SCREAMING_SNAKE_CASE   )

         a__		=			tokenizer(__SCREAMING_SNAKE_CASE   )

         for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]     ,				encoded_processor[key]   )



     def 			lowercase__  (							self   )		->     Dict:







         """simple docstring"""



         a__		=			self.get_feature_extractor()
         a__		=			self.get_tokenizer()

         a__		=			ClapProcessor(tokenizer=__SCREAMING_SNAKE_CASE     ,				feature_extractor=__SCREAMING_SNAKE_CASE   )

         a__		=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         a__		=			processor.batch_decode(__SCREAMING_SNAKE_CASE   )
         a__		=			tokenizer.batch_decode(__SCREAMING_SNAKE_CASE   )

         self.assertListEqual(__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )




     def 			lowercase__  (							self   )		->     List[Any]:







         """simple docstring"""



         a__		=			self.get_feature_extractor()
         a__		=			self.get_tokenizer()

         a__		=			ClapProcessor(tokenizer=__SCREAMING_SNAKE_CASE     ,				feature_extractor=__SCREAMING_SNAKE_CASE   )

         self.assertListEqual(
             processor.model_input_names[2:]     ,				feature_extractor.model_input_names     ,				msg='`processor` and `feature_extractor` model input names do not match'     ,				)




"""simple docstring"""




import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class     lowercase(_lowercase    ,						_lowercase    ,						unittest.TestCase       ):
     __snake_case:	Optional[int]						=     IFImgaImgSuperResolutionPipeline
     __snake_case:	Dict						=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     __snake_case:	Any						=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}       )
     __snake_case:	List[Any]						=     PipelineTesterMixin.required_optional_params - {'latents'}



     def 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         return self._get_superresolution_dummy_components()



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE=0   )		->     Union[str, Any]:







         """simple docstring"""



         if str(__SCREAMING_SNAKE_CASE   ).startswith('mps'   ):
             a__		=			torch.manual_seed(__SCREAMING_SNAKE_CASE   )
         else:
             a__		=			torch.Generator(device=__SCREAMING_SNAKE_CASE   ).manual_seed(__SCREAMING_SNAKE_CASE   )

         a__		=			floats_tensor((1, 3, 3_2, 3_2)     ,				rng=random.Random(__SCREAMING_SNAKE_CASE   )   ).to(__SCREAMING_SNAKE_CASE   )
         a__		=			floats_tensor((1, 3, 1_6, 1_6)     ,				rng=random.Random(__SCREAMING_SNAKE_CASE   )   ).to(__SCREAMING_SNAKE_CASE   )

         a__		=			{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'original_image': original_image,
             'generator': generator,
             'num_inference_steps': 2,
             'output_type': 'numpy',
         }

         return inputs



     @unittest.skipIf(
         torch_device != 'cuda' or not is_xformers_available()     ,				reason='XFormers attention is only available with CUDA and `xformers` installed'     ,				)
     def 			lowercase__  (							self   )		->     Optional[int]:







         """simple docstring"""



         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3   )



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         self._test_save_load_optional_components()



     @unittest.skipIf(torch_device != 'cuda'     ,				reason='float16 requires CUDA'   )
     def 			lowercase__  (							self   )		->     List[Any]:







         """simple docstring"""



         super().test_save_load_floataa(expected_max_diff=1e-1   )



     def 			lowercase__  (							self   )		->     List[str]:







         """simple docstring"""



         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2   )



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







         """simple docstring"""



         self._test_save_load_local()




     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         self._test_inference_batch_single_identical(
             expected_max_diff=1e-2     ,				)


