





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__					(		UpperCamelCase__							,   UpperCamelCase__							,   unittest.TestCase ):
 __SCREAMING_SNAKE_CASE							=      IFImgaImgSuperResolutionPipeline
 __SCREAMING_SNAKE_CASE							=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
 __SCREAMING_SNAKE_CASE							=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''} )
 __SCREAMING_SNAKE_CASE							=      PipelineTesterMixin.required_optional_params - {'''latents'''}



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



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase=0					):
        if str(__lowerCamelCase					).startswith('''mps'''					):
               A__		   =		torch.manual_seed(__lowerCamelCase					)
        else:
               A__		   =		torch.Generator(device=__lowerCamelCase					).manual_seed(__lowerCamelCase					)

        A__		   =		floats_tensor((1, 3, 32, 32),rng=random.Random(__lowerCamelCase					)					).to(__lowerCamelCase					)
        A__		   =		floats_tensor((1, 3, 16, 16),rng=random.Random(__lowerCamelCase					)					).to(__lowerCamelCase					)

        A__		   =		{
            '''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 							UpperCamelCase     (				self					):
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3					)



 def 							UpperCamelCase     (				self					):
        self._test_save_load_optional_components()



 @unittest.skipIf(torch_device != '''cuda''',reason='''float16 requires CUDA'''					)
 def 							UpperCamelCase     (				self					):
        # 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 							UpperCamelCase     (				self					):
        self._test_attention_slicing_forward_pass(expected_max_diff=1E-2					)



 def 							UpperCamelCase     (				self					):
        self._test_save_load_local()




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












a__: str							   =						'0.21.0'

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
       from .utils import rich





