


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 A  (   UpperCamelCase_    ,							UpperCamelCase_    ,							unittest.TestCase     ):
      UpperCamelCase__							:  str      =IFImgaImgSuperResolutionPipeline
      UpperCamelCase__							:  Dict      =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
      UpperCamelCase__							:  Optional[Any]      =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}     )
      UpperCamelCase__							:  List[str]      =PipelineTesterMixin.required_optional_params - {'latents'}






      def        lowerCamelCase       (					self						:     List[Any] )					->						Union[str, Any]:
             """simple docstring"""




             return self._get_superresolution_dummy_components()






      def        lowerCamelCase       (					self						:     Tuple			,   lowercase_						:     str			,   lowercase_						:     Optional[int]=0 )					->						Dict:
             """simple docstring"""




             if str(lowercase_ ).startswith('mps' ):
                    _lowerCamelCase       :		Dict		=torch.manual_seed(lowercase_ )
             else:
                    _lowerCamelCase       :		Tuple		=torch.Generator(device=lowercase_ ).manual_seed(lowercase_ )

             _lowerCamelCase       :		Dict		=floats_tensor((1, 3, 32, 32)			,   rng=random.Random(lowercase_ ) ).to(lowercase_ )
             _lowerCamelCase       :		str		=floats_tensor((1, 3, 16, 16)			,   rng=random.Random(lowercase_ ) ).to(lowercase_ )

             _lowerCamelCase       :		Optional[Any]		={
                 '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						:     Dict )					->						Tuple:
             """simple docstring"""




             self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )






      def        lowerCamelCase       (					self						:     Tuple )					->						List[str]:
             """simple docstring"""




             self._test_save_load_optional_components()






      @unittest.skipIf(torch_device != 'cuda'			,   reason='float16 requires CUDA' )
      def        lowerCamelCase       (					self						:     Union[str, Any] )					->						List[str]:
             """simple docstring"""




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






      def        lowerCamelCase       (					self						:     int )					->						List[Any]:
             """simple docstring"""




             self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )






      def        lowerCamelCase       (					self						:     Union[str, Any] )					->						Any:
             """simple docstring"""




             self._test_save_load_local()






      def        lowerCamelCase       (					self						:     List[str] )					->						Dict:
             """simple docstring"""




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






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


if is_sentencepiece_available():
 from ..ta.tokenization_ta import TaTokenizer
else:
 from ...utils.dummy_sentencepiece_objects import TaTokenizer

lowerCamelCase											=       TaTokenizer

if is_tokenizers_available():
 from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
 from ...utils.dummy_tokenizers_objects import TaTokenizerFast

lowerCamelCase											=       TaTokenizerFast

lowerCamelCase											=       {'configuration_mt5': ['MT5Config', 'MT5OnnxConfig']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase											=       [
     'MT5EncoderModel',
     'MT5ForConditionalGeneration',
     'MT5ForQuestionAnswering',
     'MT5Model',
     'MT5PreTrainedModel',
     'MT5Stack',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase											=       ['TFMT5EncoderModel', 'TFMT5ForConditionalGeneration', 'TFMT5Model']

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase											=       ['FlaxMT5EncoderModel', 'FlaxMT5ForConditionalGeneration', 'FlaxMT5Model']


if TYPE_CHECKING:
 from .configuration_mta import MTaConfig, MTaOnnxConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_mta import (
      MTaEncoderModel,
      MTaForConditionalGeneration,
      MTaForQuestionAnswering,
      MTaModel,
      MTaPreTrainedModel,
      MTaStack,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
 import sys

 lowerCamelCase											=       _LazyModule(
     __name__,
     globals()['__file__'],
     _import_structure,
     extra_objects={'MT5Tokenizer': MTaTokenizer, 'MT5TokenizerFast': MTaTokenizerFast},
     module_spec=__spec__,
 )


