


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


      def 							__lowerCamelCase      (				self		):
            return self._get_superresolution_dummy_components()


      def 							__lowerCamelCase      (				self				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__=0		):




            if str(A_		).startswith('''mps'''		):
                  lowercase      : Optional[Any]        =		torch.manual_seed(A_		)
            else:
                  lowercase      : Optional[int]        =		torch.Generator(device=A_		).manual_seed(A_		)

            lowercase      : int        =		floats_tensor((1, 3, 32, 32)				,    rng=random.Random(A_		)		).to(A_		)
            lowercase      : str        =		floats_tensor((1, 3, 16, 16)				,    rng=random.Random(A_		)		).to(A_		)

            lowercase      : List[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		):
            self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)


      def 							__lowerCamelCase      (				self		):
            self._test_save_load_optional_components()


      @unittest.skipIf(torch_device != '''cuda'''				,    reason='''float16 requires CUDA'''		)
      def 							__lowerCamelCase      (				self		):
            super().test_save_load_floataa(expected_max_diff=1E-1		)


      def 							__lowerCamelCase      (				self		):
            self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)


      def 							__lowerCamelCase      (				self		):
            self._test_save_load_local()






      def 							__lowerCamelCase      (				self		):
            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_tf_available,
    is_torch_available,
)


__snake_case   							=						{'''configuration_unispeech''': ['''UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechConfig''']}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __snake_case   							=						[
        '''UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''UniSpeechForCTC''',
        '''UniSpeechForPreTraining''',
        '''UniSpeechForSequenceClassification''',
        '''UniSpeechModel''',
        '''UniSpeechPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_unispeech import (
            UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST,
            UniSpeechForCTC,
            UniSpeechForPreTraining,
            UniSpeechForSequenceClassification,
            UniSpeechModel,
            UniSpeechPreTrainedModel,
        )

else:
    import sys

    __snake_case   							=						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


