


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     __snake_case							(      unittest.TestCase):
					@property
					def   a (	self					:	Tuple     )       ->				Tuple:



											'''simple docstring'''





											__magic_name__ 		=			1
											__magic_name__ 		=			3
											__magic_name__ 		=			(3_2, 3_2)

											__magic_name__ 		=			floats_tensor((batch_size, num_channels) + sizes  ,			rng=random.Random(0     )     ).to(_lowerCAmelCase     )
											return image
					@property
					def   a (	self					:	int     )       ->				Optional[int]:



											'''simple docstring'''





											torch.manual_seed(0     )
											__magic_name__ 		=			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					:	str     )       ->				Dict:



											'''simple docstring'''





											torch.manual_seed(0     )
											__magic_name__ 		=			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					:	List[Any]     )       ->				Tuple:



											'''simple docstring'''





											__magic_name__ 		=			'cpu'
											__magic_name__ 		=			self.dummy_uncond_unet
											__magic_name__ 		=			DDIMScheduler()
											__magic_name__ 		=			self.dummy_vq_model

											__magic_name__ 		=			LDMSuperResolutionPipeline(unet=_lowerCAmelCase  ,			vqvae=_lowerCAmelCase  ,			scheduler=_lowerCAmelCase     )
											ldm.to(_lowerCAmelCase     )
											ldm.set_progress_bar_config(disable=_lowerCAmelCase     )

											__magic_name__ 		=			self.dummy_image.to(_lowerCAmelCase     )

											__magic_name__ 		=			torch.Generator(device=_lowerCAmelCase     ).manual_seed(0     )
											__magic_name__ 		=			ldm(image=_lowerCAmelCase  ,			generator=_lowerCAmelCase  ,			num_inference_steps=2  ,			output_type='numpy'     ).images

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

											assert image.shape == (1, 6_4, 6_4, 3)
											__magic_name__ 		=			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					:	List[Any]     )       ->				str:



											'''simple docstring'''





											__magic_name__ 		=			self.dummy_uncond_unet
											__magic_name__ 		=			DDIMScheduler()
											__magic_name__ 		=			self.dummy_vq_model

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

											__magic_name__ 		=			LDMSuperResolutionPipeline(unet=_lowerCAmelCase  ,			vqvae=_lowerCAmelCase  ,			scheduler=_lowerCAmelCase     )
											ldm.to(_lowerCAmelCase     )
											ldm.set_progress_bar_config(disable=_lowerCAmelCase     )

											__magic_name__ 		=			self.dummy_image.to(_lowerCAmelCase     )

											__magic_name__ 		=			ldm(_lowerCAmelCase  ,			num_inference_steps=2  ,			output_type='numpy'     ).images

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







@slow
@require_torch
class     __snake_case							(      unittest.TestCase):
					def   a (	self					:	Union[str, Any]     )       ->				Any:



											'''simple docstring'''





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

											__magic_name__ 		=			LDMSuperResolutionPipeline.from_pretrained('duongna/ldm-super-resolution'  ,			device_map='auto'     )
											ldm.set_progress_bar_config(disable=_lowerCAmelCase     )

											__magic_name__ 		=			torch.manual_seed(0     )
											__magic_name__ 		=			ldm(image=_lowerCAmelCase  ,			generator=_lowerCAmelCase  ,			num_inference_steps=2_0  ,			output_type='numpy'     ).images

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

											assert image.shape == (1, 2_5_6, 2_5_6, 3)
											__magic_name__ 		=			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





import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class     __snake_case							(      _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:					Union[str, Any] 				= ["image_processor", "tokenizer"]
					SCREAMING_SNAKE_CASE_		:					Tuple 				= "AutoImageProcessor"
					SCREAMING_SNAKE_CASE_		:					Dict 				= "AutoTokenizer"
					def __init__(	self					:	List[str]  ,			_lowerCAmelCase					:	str=None  ,			_lowerCAmelCase					:	Dict=None  ,			**_lowerCAmelCase					:	List[str]     )       ->				Optional[int]:



											'''simple docstring'''





											__magic_name__ 		=			None
											if "feature_extractor" in kwargs:
																	warnings.warn(
																	    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
																	    ' instead.'  ,			_lowerCAmelCase  ,			)
																	__magic_name__ 		=			kwargs.pop('feature_extractor'     )

											__magic_name__ 		=			image_processor if image_processor is not None else feature_extractor
											if image_processor is None:
																	raise ValueError('You have to specify an image_processor.'     )
											if tokenizer is None:
																	raise ValueError('You have to specify a tokenizer.'     )

											super().__init__(_lowerCAmelCase  ,			_lowerCAmelCase     )
											__magic_name__ 		=			self.image_processor
					def __call__(	self					:	str  ,			_lowerCAmelCase					:	Any=None  ,			_lowerCAmelCase					:	int=None  ,			_lowerCAmelCase					:	List[str]=None  ,			**_lowerCAmelCase					:	int     )       ->				int:



											'''simple docstring'''





											if text is None and images is None:
																	raise ValueError('You have to specify either text or images. Both cannot be none.'     )

											if text is not None:
																	__magic_name__ 		=			self.tokenizer(_lowerCAmelCase  ,			return_tensors=_lowerCAmelCase  ,			**_lowerCAmelCase     )

											if images is not None:
																	__magic_name__ 		=			self.image_processor(_lowerCAmelCase  ,			return_tensors=_lowerCAmelCase  ,			**_lowerCAmelCase     )

											if text is not None and images is not None:
																	__magic_name__ 		=			image_features.pixel_values
																	return encoding
											elif text is not None:
																	return encoding
											else:
																	return BatchEncoding(data=dict(**_lowerCAmelCase     )  ,			tensor_type=_lowerCAmelCase     )
					def   a (	self					:	Optional[int]  ,			*_lowerCAmelCase					:	Optional[int]  ,			**_lowerCAmelCase					:	Optional[Any]     )       ->				Optional[int]:



											'''simple docstring'''





											return self.tokenizer.batch_decode(*_lowerCAmelCase  ,			**_lowerCAmelCase     )
					def   a (	self					:	Union[str, Any]  ,			*_lowerCAmelCase					:	str  ,			**_lowerCAmelCase					:	Tuple     )       ->				int:



											'''simple docstring'''





											return self.tokenizer.decode(*_lowerCAmelCase  ,			**_lowerCAmelCase     )
					@property
					def   a (	self					:	List[Any]     )       ->				Tuple:



											'''simple docstring'''





											__magic_name__ 		=			self.tokenizer.model_input_names
											__magic_name__ 		=			self.image_processor.model_input_names
											return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names     )     )
					@property
					def   a (	self					:	Optional[Any]     )       ->				Dict:



											'''simple docstring'''





											warnings.warn(
											    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'  ,			_lowerCAmelCase  ,			)
											return self.image_processor_class







					@property
					def   a (	self					:	Dict     )       ->				Tuple:



											'''simple docstring'''





											warnings.warn(
											    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'  ,			_lowerCAmelCase  ,			)
											return self.image_processor

