



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       ):


					"""simple docstring"""



					@property
					def 				__UpperCAmelCase		(		self     :List[str]    ):
										lowercase						   =       1
										lowercase						   =       3
										lowercase						   =       (32, 32)

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

					@property
					def 				__UpperCAmelCase		(		self     :Dict    ):
										torch.manual_seed(0    )
										lowercase						   =       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 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										torch.manual_seed(0    )
										lowercase						   =       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 				__UpperCAmelCase		(		self     :Tuple    ):
										lowercase						   =       'cpu'
										lowercase						   =       self.dummy_uncond_unet
										lowercase						   =       DDIMScheduler()
										lowercase						   =       self.dummy_vq_model

										lowercase						   =       LDMSuperResolutionPipeline(unet=lowercase__      ,  vqvae=lowercase__      ,  scheduler=lowercase__    )
										ldm.to(lowercase__    )
										ldm.set_progress_bar_config(disable=lowercase__    )

										lowercase						   =       self.dummy_image.to(lowercase__    )

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

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

										assert image.shape == (1, 64, 64, 3)
										lowercase						   =       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 				__UpperCAmelCase		(		self     :Dict    ):
										lowercase						   =       self.dummy_uncond_unet
										lowercase						   =       DDIMScheduler()
										lowercase						   =       self.dummy_vq_model

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

										lowercase						   =       LDMSuperResolutionPipeline(unet=lowercase__      ,  vqvae=lowercase__      ,  scheduler=lowercase__    )
										ldm.to(lowercase__    )
										ldm.set_progress_bar_config(disable=lowercase__    )

										lowercase						   =       self.dummy_image.to(lowercase__    )

										lowercase						   =       ldm(lowercase__      ,  num_inference_steps=2      ,  output_type='numpy'    ).images

										assert image.shape == (1, 64, 64, 3)




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


					"""simple docstring"""



					def 				__UpperCAmelCase		(		self     :List[Any]    ):
										lowercase						   =       load_image(
										    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
										    '/vq_diffusion/teddy_bear_pool.png'    )
										lowercase						   =       init_image.resize((64, 64)      ,  resample=PIL_INTERPOLATION['lanczos']    )

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

										lowercase						   =       torch.manual_seed(0    )
										lowercase						   =       ldm(image=lowercase__      ,  generator=lowercase__      ,  num_inference_steps=20      ,  output_type='numpy'    ).images

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

										assert image.shape == (1, 256, 256, 3)
										lowercase						   =       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 unittest

from transformers import BlenderbotTokenizer, BlenderbotTokenizerFast
from transformers.utils import cached_property


class 	a__       (       unittest.TestCase       ):


					"""simple docstring"""



					@cached_property
					def 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										return BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B'    )

					@cached_property
					def 				__UpperCAmelCase		(		self     :Any    ):
										return BlenderbotTokenizerFast.from_pretrained('facebook/blenderbot-3B'    )

					def 				__UpperCAmelCase		(		self     :str    ):
										lowercase						   =       self.tokenizer_ab
										lowercase						   =       ' I am a small frog.'
										lowercase						   =       tok([src_text]      ,  padding=lowercase__      ,  truncation=lowercase__    )['input_ids']
										lowercase						   =       tok.batch_decode(lowercase__      ,  skip_special_tokens=lowercase__      ,  clean_up_tokenization_spaces=lowercase__    )[0]
										assert src_text == decoded

					def 				__UpperCAmelCase		(		self     :Union[str, Any]    ):
										lowercase						   =       self.rust_tokenizer_ab
										lowercase						   =       ' I am a small frog.'
										lowercase						   =       tok([src_text]      ,  padding=lowercase__      ,  truncation=lowercase__    )['input_ids']
										lowercase						   =       tok.batch_decode(lowercase__      ,  skip_special_tokens=lowercase__      ,  clean_up_tokenization_spaces=lowercase__    )[0]
										assert src_text == decoded

					def 				__UpperCAmelCase		(		self     :Any    ):
										assert self.tokenizer_ab.add_prefix_space
										assert self.tokenizer_ab([' Sam', 'Sam']    ).input_ids == [[5502, 2], [5502, 2]]



					def 				__UpperCAmelCase		(		self     :Union[str, Any]    ):
										assert self.rust_tokenizer_ab.add_prefix_space
										assert self.rust_tokenizer_ab([' Sam', 'Sam']    ).input_ids == [[5502, 2], [5502, 2]]






