


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 	__lowerCamelCase			(_a				,      _a				,      unittest.TestCase						):
       _lowercase											=     IFImgaImgSuperResolutionPipeline
       _lowercase											=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
       _lowercase											=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}						)
       _lowercase											=     PipelineTesterMixin.required_optional_params - {"""latents"""}







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            return self._get_superresolution_dummy_components()







       def 		snake_case_	(			self: List[str],A_: int,A_: Union[str, Any]=0					):






            '''simple docstring'''




            if str(A_					).startswith('mps'					):
                 __UpperCamelCase =			torch.manual_seed(A_					)
            else:
                 __UpperCamelCase =			torch.Generator(device=A_					).manual_seed(A_					)

            __UpperCamelCase =			floats_tensor((1, 3, 32, 32),rng=random.Random(A_					)					).to(A_					)
            __UpperCamelCase =			floats_tensor((1, 3, 16, 16),rng=random.Random(A_					)					).to(A_					)

            __UpperCamelCase =			{
                '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 		snake_case_	(			self: int					):






            '''simple docstring'''




            self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3					)







       def 		snake_case_	(			self: Optional[int]					):






            '''simple docstring'''




            self._test_save_load_optional_components()







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






            '''simple docstring'''




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







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            self._test_attention_slicing_forward_pass(expected_max_diff=1E-2					)







       def 		snake_case_	(			self: int					):






            '''simple docstring'''




            self._test_save_load_local()







       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




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










'''simple docstring'''







import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  _a  : List[Any]      			=     ['''image_processor''', '''tokenizer''']
  _a  : List[Any]      			=     '''ViTImageProcessor'''
  _a  : int      			=     ('''CLIPTokenizer''', '''CLIPTokenizerFast''')







  def __init__(			self   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	**UpperCamelCase__	):






         """simple docstring"""


         a_						     =			None
         if "feature_extractor" in kwargs:
                warnings.warn(
                    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                    ' instead.'   ,	UpperCamelCase__   ,	)
                a_						     =			kwargs.pop('feature_extractor'	)

         a_						     =			image_processor if image_processor is not None else feature_extractor
         if image_processor is None:
                raise ValueError('You need to specify an `image_processor`.'	)
         if tokenizer is None:
                raise ValueError('You need to specify a `tokenizer`.'	)

         super().__init__(UpperCamelCase__   ,	UpperCamelCase__	)







  def __call__(			self   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	UpperCamelCase__=None   ,	**UpperCamelCase__	):






         """simple docstring"""


         if text is None and visual_prompt is None and images is None:
                raise ValueError('You have to specify either text, visual prompt or images.'	)

         if text is not None and visual_prompt is not None:
                raise ValueError('You have to specify exactly one type of prompt. Either text or visual prompt.'	)

         if text is not None:
                a_						     =			self.tokenizer(UpperCamelCase__   ,	return_tensors=UpperCamelCase__   ,	**UpperCamelCase__	)

         if visual_prompt is not None:
                a_						     =			self.image_processor(UpperCamelCase__   ,	return_tensors=UpperCamelCase__   ,	**UpperCamelCase__	)

         if images is not None:
                a_						     =			self.image_processor(UpperCamelCase__   ,	return_tensors=UpperCamelCase__   ,	**UpperCamelCase__	)

         if visual_prompt is not None and images is not None:
                a_						     =			{
                    'pixel_values': image_features.pixel_values,
                    'conditional_pixel_values': prompt_features.pixel_values,
                }
                return encoding
         elif text is not None and images is not None:
                a_						     =			image_features.pixel_values
                return encoding
         elif text is not None:
                return encoding
         elif visual_prompt is not None:
                a_						     =			{
                    'conditional_pixel_values': prompt_features.pixel_values,
                }
                return encoding
         else:
                return BatchEncoding(data=dict(**UpperCamelCase__	)   ,	tensor_type=UpperCamelCase__	)







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         return self.tokenizer.batch_decode(*UpperCamelCase__   ,	**UpperCamelCase__	)







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         return self.tokenizer.decode(*UpperCamelCase__   ,	**UpperCamelCase__	)







  @property
  def    _a       (			self	):






         """simple docstring"""


         warnings.warn(
             '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'   ,	UpperCamelCase__   ,	)
         return self.image_processor_class







  @property
  def    _a       (			self	):






         """simple docstring"""


         warnings.warn(
             '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'   ,	UpperCamelCase__   ,	)
         return self.image_processor




