"""simple docstring"""







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


UpperCamelCase_    :    List[str]											=						logging.get_logger(__name__)


class      _lowercase						(				__lowerCamelCase					):
				lowerCamelCase__									=    'speech-encoder-decoder'
				lowerCamelCase__									=    True

				def __init__(       self    :      Tuple    ,      **_lowercase    :      Any       ):


										'''simple docstring'''
										super().__init__(**_lowercase       )
										if "encoder" not in kwargs or "decoder" not in kwargs:
																raise ValueError(
																    f'A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'
																    f' `decoder` sub-configurations are passed, but only {kwargs}'       )

										UpperCAmelCase__   		=						kwargs.pop("""encoder"""       )
										UpperCAmelCase__   		=						encoder_config.pop("""model_type"""       )
										UpperCAmelCase__   		=						kwargs.pop("""decoder"""       )
										UpperCAmelCase__   		=						decoder_config.pop("""model_type"""       )

										UpperCAmelCase__   		=						AutoConfig.for_model(_lowercase    ,      **_lowercase       )
										UpperCAmelCase__   		=						AutoConfig.for_model(_lowercase    ,      **_lowercase       )
										UpperCAmelCase__   		=						True

				@classmethod
				def     A	(       cls    :      Dict    ,      _lowercase    :      PretrainedConfig    ,      _lowercase    :      PretrainedConfig    ,      **_lowercase    :      int       ):


										'''simple docstring'''
										logger.info("""Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"""       )
										UpperCAmelCase__   		=						True
										UpperCAmelCase__   		=						True

										return cls(encoder=encoder_config.to_dict()    ,      decoder=decoder_config.to_dict()    ,      **_lowercase       )

				def     A	(       self    :      int       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						copy.deepcopy(self.__dict__       )
										UpperCAmelCase__   		=						self.encoder.to_dict()
										UpperCAmelCase__   		=						self.decoder.to_dict()
										UpperCAmelCase__   		=						self.__class__.model_type
										return output


"""simple docstring"""







import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()


class      _lowercase						(				unittest.TestCase					):

				@property
				def     A	(       self    :      Any       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						1
										UpperCAmelCase__   		=						3
										UpperCAmelCase__   		=						(3_2, 3_2)

										UpperCAmelCase__   		=						floats_tensor((batch_size, num_channels) + sizes    ,      rng=random.Random(0       )       ).to(_lowercase       )
										return image

				@property
				def     A	(       self    :      List[str]       ):


										'''simple docstring'''
										torch.manual_seed(0       )
										UpperCAmelCase__   		=						UNetaDModel(
										    block_out_channels=(3_2, 6_4)    ,      layers_per_block=2    ,      sample_size=3_2    ,      in_channels=6    ,      out_channels=3    ,      down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")    ,      up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")    ,      )
										return model

				@property
				def     A	(       self    :      Tuple       ):


										'''simple docstring'''
										torch.manual_seed(0       )
										UpperCAmelCase__   		=						VQModel(
										    block_out_channels=[3_2, 6_4]    ,      in_channels=3    ,      out_channels=3    ,      down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]    ,      up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]    ,      latent_channels=3    ,      )
										return model

				def     A	(       self    :      Any       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						"""cpu"""
										UpperCAmelCase__   		=						self.dummy_uncond_unet
										UpperCAmelCase__   		=						DDIMScheduler()
										UpperCAmelCase__   		=						self.dummy_vq_model

										UpperCAmelCase__   		=						LDMSuperResolutionPipeline(unet=_lowercase    ,      vqvae=_lowercase    ,      scheduler=_lowercase       )
										ldm.to(_lowercase       )
										ldm.set_progress_bar_config(disable=_lowercase       )

										UpperCAmelCase__   		=						self.dummy_image.to(_lowercase       )

										UpperCAmelCase__   		=						torch.Generator(device=_lowercase       ).manual_seed(0       )
										UpperCAmelCase__   		=						ldm(image=_lowercase    ,      generator=_lowercase    ,      num_inference_steps=2    ,      output_type="""numpy"""       ).images

										UpperCAmelCase__   		=						image[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										UpperCAmelCase__   		=						np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]       )

										assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2

				@unittest.skipIf(torch_device != """cuda"""    ,      """This test requires a GPU"""       )
				def     A	(       self    :      Dict       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						self.dummy_uncond_unet
										UpperCAmelCase__   		=						DDIMScheduler()
										UpperCAmelCase__   		=						self.dummy_vq_model

										# put models in fp16
										UpperCAmelCase__   		=						unet.half()
										UpperCAmelCase__   		=						vqvae.half()

										UpperCAmelCase__   		=						LDMSuperResolutionPipeline(unet=_lowercase    ,      vqvae=_lowercase    ,      scheduler=_lowercase       )
										ldm.to(_lowercase       )
										ldm.set_progress_bar_config(disable=_lowercase       )

										UpperCAmelCase__   		=						self.dummy_image.to(_lowercase       )

										UpperCAmelCase__   		=						ldm(_lowercase    ,      num_inference_steps=2    ,      output_type="""numpy"""       ).images

										assert image.shape == (1, 6_4, 6_4, 3)


@slow
@require_torch
class      _lowercase						(				unittest.TestCase					):

				def     A	(       self    :      List[Any]       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						load_image(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
										    """/vq_diffusion/teddy_bear_pool.png"""       )
										UpperCAmelCase__   		=						init_image.resize((6_4, 6_4)    ,      resample=PIL_INTERPOLATION["""lanczos"""]       )

										UpperCAmelCase__   		=						LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""    ,      device_map="""auto"""       )
										ldm.set_progress_bar_config(disable=_lowercase       )

										UpperCAmelCase__   		=						torch.manual_seed(0       )
										UpperCAmelCase__   		=						ldm(image=_lowercase    ,      generator=_lowercase    ,      num_inference_steps=2_0    ,      output_type="""numpy"""       ).images

										UpperCAmelCase__   		=						image[0, -3:, -3:, -1]

										assert image.shape == (1, 2_5_6, 2_5_6, 3)
										UpperCAmelCase__   		=						np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]       )

										assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2

