import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
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 				a_ (						SCREAMING_SNAKE_CASE       ,     SCREAMING_SNAKE_CASE       ,     unittest.TestCase						):






 '''simple docstring'''






 UpperCAmelCase_	 =					IFImgaImgPipeline
 UpperCAmelCase_	 =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
 UpperCAmelCase_	 =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 UpperCAmelCase_	 =					PipelineTesterMixin.required_optional_params - {'latents'}




 def 		__snake_case						(			self					:  int):







        '''simple docstring'''



        return self._get_dummy_components()




 def 		__snake_case						(			self					:  List[str]			,    lowercase__					:  int			,    lowercase__					:  Any=0):







        '''simple docstring'''



        if str(lowercase__).startswith('mps'):
               lowerCAmelCase__     	=					torch.manual_seed(lowercase__)
        else:
               lowerCAmelCase__     	=					torch.Generator(device=lowercase__).manual_seed(lowercase__)

        lowerCAmelCase__     	=					floats_tensor((1, 3, 32, 32)			,    rng=random.Random(lowercase__)).to(lowercase__)

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

        return inputs




 def 		__snake_case						(			self					:  List[str]):







        '''simple docstring'''



        self._test_save_load_optional_components()




 @unittest.skipIf(
     torch_device != 'cuda' or not is_xformers_available()			,    reason='XFormers attention is only available with CUDA and `xformers` installed'			,    )
 def 		__snake_case						(			self					:  Any):







        '''simple docstring'''



        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)




 @unittest.skipIf(torch_device != 'cuda'			,    reason='float16 requires CUDA')
 def 		__snake_case						(			self					:  List[str]):







        '''simple docstring'''



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




 @unittest.skipIf(torch_device != 'cuda'			,    reason='float16 requires CUDA')
 def 		__snake_case						(			self					:  Optional[Any]):







        '''simple docstring'''



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




 def 		__snake_case						(			self					:  List[str]):







        '''simple docstring'''



        self._test_attention_slicing_forward_pass(expected_max_diff=1e-2)




 def 		__snake_case						(			self					:  str):







        '''simple docstring'''



        self._test_save_load_local()




 def 		__snake_case						(			self					:  List[Any]):







        '''simple docstring'''



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







import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
	import torch




class      UpperCamelCase_				(   unittest.TestCase ,     UpperCamelCase__			):


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					load_tool("""speech-to-text"""						)
									self.tool.setup()


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.tool(torch.ones(3000						)						)
									self.assertEqual(__A							, """ you"""						)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.tool(audio=torch.ones(3000						)						)
									self.assertEqual(__A							, """ you"""						)