



'''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     UpperCAmelCase_       (       _a		,		_a		,		unittest.TestCase	):
    """simple docstring"""







    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 lowerCamelCase       (    self					:     str						):
          return self._get_superresolution_dummy_components()




    def lowerCamelCase       (    self					:     Any ,     snake_case_					:     Optional[Any] ,     snake_case_					:     List[str]=0						):
          if str(snake_case_						).startswith("""mps"""						):
                snake_case__  :    List[str]    						=      torch.manual_seed(snake_case_						)
          else:
                snake_case__  :    Optional[Any]    						=      torch.Generator(device=snake_case_						).manual_seed(snake_case_						)

          snake_case__  :    int    						=      floats_tensor((1, 3, 32, 32) ,     rng=random.Random(snake_case_						)						).to(snake_case_						)
          snake_case__  :    List[str]    						=      floats_tensor((1, 3, 16, 16) ,     rng=random.Random(snake_case_						)						).to(snake_case_						)

          snake_case__  :    int    						=      {
              """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 lowerCamelCase       (    self					:     Optional[Any]						):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3						)




    def lowerCamelCase       (    self					:     int						):
          self._test_save_load_optional_components()




    @unittest.skipIf(torch_device != """cuda""" ,     reason="""float16 requires CUDA"""						)
    def lowerCamelCase       (    self					:     Optional[int]						):
          # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
          super().test_save_load_floataa(expected_max_diff=1E-1						)




    def lowerCamelCase       (    self					:     List[Any]						):
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2						)




    def lowerCamelCase       (    self					:     Dict						):
          self._test_save_load_local()




    def lowerCamelCase       (    self					:     Union[str, Any]						):
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2 ,     )





'''simple docstring'''





import numpy as np

from transformers import Pipeline





def 						__snake_case(				_lowerCAmelCase		)		-> Optional[int]:
      snake_case__  :    Optional[Any]    						=      np.max(_lowerCAmelCase     ,   axis=-1     ,   keepdims=_lowerCAmelCase		)
      snake_case__  :    List[str]    						=      np.exp(outputs - maxes		)
      return shifted_exp / shifted_exp.sum(axis=-1     ,   keepdims=_lowerCAmelCase		)







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    def lowerCamelCase       (    self					:     Optional[Any] ,     **snake_case_					:     int						):
          snake_case__  :    Optional[int]    						=      {}
          if "second_text" in kwargs:
                snake_case__  :    Union[str, Any]    						=      kwargs["""second_text"""]
          return preprocess_kwargs, {}, {}




    def lowerCamelCase       (    self					:     str ,     snake_case_					:     Tuple ,     snake_case_					:     Union[str, Any]=None						):
          return self.tokenizer(snake_case_ ,     text_pair=snake_case_ ,     return_tensors=self.framework						)




    def lowerCamelCase       (    self					:     List[Any] ,     snake_case_					:     Dict						):
          return self.model(**snake_case_						)




    def lowerCamelCase       (    self					:     int ,     snake_case_					:     List[Any]						):
          snake_case__  :    Union[str, Any]    						=      model_outputs.logits[0].numpy()
          snake_case__  :    List[str]    						=      softmax(snake_case_						)

          snake_case__  :    List[str]    						=      np.argmax(snake_case_						)
          snake_case__  :    List[str]    						=      self.model.config.idalabel[best_class]
          snake_case__  :    Optional[int]    						=      probabilities[best_class].item()
          snake_case__  :    str    						=      logits.tolist()
          return {"label": label, "score": score, "logits": logits}
