



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 							a_  (		unittest.TestCase				):

						@property
						def 	__a       (    self	:int)		->					Optional[Any]:
												UpperCAmelCase_     							=     1
												UpperCAmelCase_     							=     3
												UpperCAmelCase_     							=     (32, 32)

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

						@property
						def 	__a       (    self	:List[str])		->					int:
												torch.manual_seed(0)
												UpperCAmelCase_     							=     UNetaDModel(
												    block_out_channels=(32, 64)   ,						layers_per_block=2   ,						sample_size=32   ,						in_channels=6   ,						out_channels=3   ,						down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')   ,						up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')   ,						)
												return model

						@property
						def 	__a       (    self	:List[str])		->					Dict:
												torch.manual_seed(0)
												UpperCAmelCase_     							=     VQModel(
												    block_out_channels=[32, 64]   ,						in_channels=3   ,						out_channels=3   ,						down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,						up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,						latent_channels=3   ,						)
												return model

						def 	__a       (    self	:Dict)		->					str:
												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, 64, 64, 3)
												UpperCAmelCase_     							=     np.array([0.8_678, 0.8_245, 0.6_381, 0.6_830, 0.4_385, 0.5_599, 0.4_641, 0.6_201, 0.5_150])

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




						@unittest.skipIf(torch_device != '''cuda'''   ,						'''This test requires a GPU''')
						def 	__a       (    self	:Optional[Any])		->					Dict:
												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, 64, 64, 3)







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

						def 	__a       (    self	:List[Any])		->					Optional[Any]:
												UpperCAmelCase_     							=     load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/vq_diffusion/teddy_bear_pool.png''')
												UpperCAmelCase_     							=     init_image.resize((64, 64)   ,						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=20   ,						output_type='''numpy''').images

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

												assert image.shape == (1, 256, 256, 3)
												UpperCAmelCase_     							=     np.array([0.7_644, 0.7_679, 0.7_642, 0.7_633, 0.7_666, 0.7_560, 0.7_425, 0.7_257, 0.6_907])

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










import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
							from PIL import Image







class 							a_  (		unittest.TestCase					, _snake_case				):

						def 	__a       (    self	:Union[str, Any])		->					Optional[Any]:
												UpperCAmelCase_     							=     load_tool('''image-question-answering''')
												self.tool.setup()
												UpperCAmelCase_     							=     load_tool('''image-question-answering'''   ,						remote=_lowercase)

						def 	__a       (    self	:int)		->					Union[str, Any]:
												UpperCAmelCase_     							=     Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO''')) / '''000000039769.png''')
												UpperCAmelCase_     							=     self.tool(_lowercase   ,						'''How many cats are sleeping on the couch?''')
												self.assertEqual(_lowercase   ,						'''2''')

						def 	__a       (    self	:int)		->					Dict:
												UpperCAmelCase_     							=     Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO''')) / '''000000039769.png''')
												UpperCAmelCase_     							=     self.remote_tool(_lowercase   ,						'''How many cats are sleeping on the couch?''')
												self.assertEqual(_lowercase   ,						'''2''')

						def 	__a       (    self	:Optional[int])		->					int:
												UpperCAmelCase_     							=     Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO''')) / '''000000039769.png''')
												UpperCAmelCase_     							=     self.tool(image=_lowercase   ,						question='''How many cats are sleeping on the couch?''')
												self.assertEqual(_lowercase   ,						'''2''')




						def 	__a       (    self	:Optional[Any])		->					List[str]:
												UpperCAmelCase_     							=     Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO''')) / '''000000039769.png''')
												UpperCAmelCase_     							=     self.remote_tool(image=_lowercase   ,						question='''How many cats are sleeping on the couch?''')
												self.assertEqual(_lowercase   ,						'''2''')





