


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






      @property
      def 	__lowercase(     self					:   Union[str, Any]   )  -> Optional[int]:
           UpperCamelCase__							:  List[Any]								=     1
           UpperCamelCase__							:  Union[str, Any]								=     3
           UpperCamelCase__							:  List[Any]								=     (32, 32)

           UpperCamelCase__							:  Optional[int]								=     floats_tensor((batch_size, num_channels) + sizes,		rng=random.Random(0   )   ).to(__lowerCamelCase   )
           return image






      @property
      def 	__lowercase(     self					:   Optional[Any]   )  -> str:
           torch.manual_seed(0   )
           UpperCamelCase__							:  str								=     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 	__lowercase(     self					:   Union[str, Any]   )  -> str:
           torch.manual_seed(0   )
           UpperCamelCase__							:  Optional[int]								=     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 	__lowercase(     self					:   Optional[Any]   )  -> Dict:
           UpperCamelCase__							:  Optional[Any]								=     '''cpu'''
           UpperCamelCase__							:  Any								=     self.dummy_uncond_unet
           UpperCamelCase__							:  Dict								=     DDIMScheduler()
           UpperCamelCase__							:  Optional[Any]								=     self.dummy_vq_model

           UpperCamelCase__							:  List[str]								=     LDMSuperResolutionPipeline(unet=__lowerCamelCase,		vqvae=__lowerCamelCase,		scheduler=__lowerCamelCase   )
           ldm.to(__lowerCamelCase   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  Any								=     self.dummy_image.to(__lowerCamelCase   )

           UpperCamelCase__							:  Any								=     torch.Generator(device=__lowerCamelCase   ).manual_seed(0   )
           UpperCamelCase__							:  List[str]								=     ldm(image=__lowerCamelCase,		generator=__lowerCamelCase,		num_inference_steps=2,		output_type='''numpy'''   ).images

           UpperCamelCase__							:  List[Any]								=     image[0, -3:, -3:, -1]

           assert image.shape == (1, 64, 64, 3)
           UpperCamelCase__							:  Optional[int]								=     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 	__lowercase(     self					:   Dict   )  -> Tuple:
           UpperCamelCase__							:  Dict								=     self.dummy_uncond_unet
           UpperCamelCase__							:  Optional[Any]								=     DDIMScheduler()
           UpperCamelCase__							:  Dict								=     self.dummy_vq_model

           # put models in fp16
           UpperCamelCase__							:  str								=     unet.half()
           UpperCamelCase__							:  Dict								=     vqvae.half()

           UpperCamelCase__							:  List[str]								=     LDMSuperResolutionPipeline(unet=__lowerCamelCase,		vqvae=__lowerCamelCase,		scheduler=__lowerCamelCase   )
           ldm.to(__lowerCamelCase   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  List[str]								=     self.dummy_image.to(__lowerCamelCase   )

           UpperCamelCase__							:  str								=     ldm(__lowerCamelCase,		num_inference_steps=2,		output_type='''numpy'''   ).images

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

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






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

           UpperCamelCase__							:  Optional[int]								=     LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution''',		device_map='''auto'''   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  Union[str, Any]								=     torch.manual_seed(0   )
           UpperCamelCase__							:  Optional[Any]								=     ldm(image=__lowerCamelCase,		generator=__lowerCamelCase,		num_inference_steps=20,		output_type='''numpy'''   ).images

           UpperCamelCase__							:  Optional[int]								=     image[0, -3:, -3:, -1]

           assert image.shape == (1, 2_56, 2_56, 3)
           UpperCamelCase__							:  Any								=     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  UpperCamelCase__ ( unittest.TestCase			):






      @cached_property
      def 	__lowercase(     self					:   List[Any]   )  -> int:
           return BlenderbotTokenizer.from_pretrained('''facebook/blenderbot-3B'''   )






      @cached_property
      def 	__lowercase(     self					:   List[Any]   )  -> Tuple:
           return BlenderbotTokenizerFast.from_pretrained('''facebook/blenderbot-3B'''   )






      def 	__lowercase(     self					:   List[str]   )  -> Optional[int]:
           UpperCamelCase__							:  Optional[Any]								=     self.tokenizer_ab
           UpperCamelCase__							:  str								=     ''' I am a small frog.'''
           UpperCamelCase__							:  Dict								=     tok([src_text],		padding=__lowerCamelCase,		truncation=__lowerCamelCase   )['''input_ids''']
           UpperCamelCase__							:  List[str]								=     tok.batch_decode(__lowerCamelCase,		skip_special_tokens=__lowerCamelCase,		clean_up_tokenization_spaces=__lowerCamelCase   )[0]
           assert src_text == decoded






      def 	__lowercase(     self					:   int   )  -> Any:
           UpperCamelCase__							:  str								=     self.rust_tokenizer_ab
           UpperCamelCase__							:  Optional[int]								=     ''' I am a small frog.'''
           UpperCamelCase__							:  List[str]								=     tok([src_text],		padding=__lowerCamelCase,		truncation=__lowerCamelCase   )['''input_ids''']
           UpperCamelCase__							:  Optional[int]								=     tok.batch_decode(__lowerCamelCase,		skip_special_tokens=__lowerCamelCase,		clean_up_tokenization_spaces=__lowerCamelCase   )[0]
           assert src_text == decoded






      def 	__lowercase(     self					:   Optional[int]   )  -> Optional[Any]:
           assert self.tokenizer_ab.add_prefix_space
           assert self.tokenizer_ab([''' Sam''', '''Sam''']   ).input_ids == [[55_02, 2], [55_02, 2]]






      def 	__lowercase(     self					:   Union[str, Any]   )  -> Optional[int]:
           assert self.rust_tokenizer_ab.add_prefix_space
           assert self.rust_tokenizer_ab([''' Sam''', '''Sam''']   ).input_ids == [[55_02, 2], [55_02, 2]]




