"""simple docstring"""







import numpy as np  # noqa: E402

from ...configuration_utils import ConfigMixin, register_to_config
from ...schedulers.scheduling_utils import SchedulerMixin


try:
						import librosa  # noqa: E402

						UpperCamelCase_    :    Union[str, Any]											=						True
						UpperCamelCase_    :    int											=						""""""
except Exception as e:
						UpperCamelCase_    :    Any											=						False
						UpperCamelCase_    :    Any											=						(
						    F"""Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it."""
						)


from PIL import Image  # noqa: E402


class      _lowercase						(				__lowerCamelCase , __lowerCamelCase					):
				lowerCamelCase__									=    'mel_config.json'

				@register_to_config
				def __init__(       self    :      int    ,      _lowercase    :      int = 2_5_6    ,      _lowercase    :      int = 2_5_6    ,      _lowercase    :      int = 2_2_0_5_0    ,      _lowercase    :      int = 2_0_4_8    ,      _lowercase    :      int = 5_1_2    ,      _lowercase    :      int = 8_0    ,      _lowercase    :      int = 3_2    ,      ):


										'''simple docstring'''
										UpperCAmelCase__   		=						hop_length
										UpperCAmelCase__   		=						sample_rate
										UpperCAmelCase__   		=						n_fft
										UpperCAmelCase__   		=						top_db
										UpperCAmelCase__   		=						n_iter
										self.set_resolution(_lowercase    ,      _lowercase       )
										UpperCAmelCase__   		=						None

										if not _librosa_can_be_imported:
																raise ValueError(_import_error       )

				def     A	(       self    :      Any    ,      _lowercase    :      int    ,      _lowercase    :      int       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						x_res
										UpperCAmelCase__   		=						y_res
										UpperCAmelCase__   		=						self.y_res
										UpperCAmelCase__   		=						self.x_res * self.hop_length - 1

				def     A	(       self    :      Dict    ,      _lowercase    :      str = None    ,      _lowercase    :      np.ndarray = None       ):


										'''simple docstring'''
										if audio_file is not None:
																UpperCAmelCase__		, UpperCAmelCase__   		=						librosa.load(_lowercase    ,      mono=_lowercase    ,      sr=self.sr       )
										else:
																UpperCAmelCase__   		=						raw_audio

										# Pad with silence if necessary.
										if len(self.audio       ) < self.x_res * self.hop_length:
																UpperCAmelCase__   		=						np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio       ),)       )]       )

				def     A	(       self    :      int       ):


										'''simple docstring'''
										return len(self.audio       ) // self.slice_size

				def     A	(       self    :      Optional[int]    ,      _lowercase    :      int = 0       ):


										'''simple docstring'''
										return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]

				def     A	(       self    :      Dict       ):


										'''simple docstring'''
										return self.sr

				def     A	(       self    :      int    ,      _lowercase    :      int       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						librosa.feature.melspectrogram(
										    y=self.get_audio_slice(_lowercase       )    ,      sr=self.sr    ,      n_fft=self.n_fft    ,      hop_length=self.hop_length    ,      n_mels=self.n_mels       )
										UpperCAmelCase__   		=						librosa.power_to_db(_lowercase    ,      ref=np.max    ,      top_db=self.top_db       )
										UpperCAmelCase__   		=						(((log_S + self.top_db) * 2_5_5 / self.top_db).clip(0    ,      2_5_5       ) + 0.5).astype(np.uinta       )
										UpperCAmelCase__   		=						Image.fromarray(_lowercase       )
										return image

				def     A	(       self    :      Dict    ,      _lowercase    :      Image.Image       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						np.frombuffer(image.tobytes()    ,      dtype="""uint8"""       ).reshape((image.height, image.width)       )
										UpperCAmelCase__   		=						bytedata.astype("""float"""       ) * self.top_db / 2_5_5 - self.top_db
										UpperCAmelCase__   		=						librosa.db_to_power(_lowercase       )
										UpperCAmelCase__   		=						librosa.feature.inverse.mel_to_audio(
										    _lowercase    ,      sr=self.sr    ,      n_fft=self.n_fft    ,      hop_length=self.hop_length    ,      n_iter=self.n_iter       )
										return audio


"""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

