"""simple docstring"""




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class 						a__							(       unittest.TestCase		):



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



			@property
			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								__a		 =       1
								__a		 =       3
								__a		 =       (3_2, 3_2)

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



			@property
			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								torch.manual_seed(0   )
								__a		 =       UNetaDConditionModel(
								    block_out_channels=(3_2, 3_2, 6_4)				,						layers_per_block=2				,						sample_size=3_2				,						in_channels=7				,						out_channels=4				,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')				,						up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')				,						cross_attention_dim=3_2				,						attention_head_dim=8				,						use_linear_projection=A__				,						only_cross_attention=(True, True, False)				,						num_class_embeds=1_0_0				,						)
								return model



			@property
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								torch.manual_seed(0   )
								__a		 =       AutoencoderKL(
								    block_out_channels=[3_2, 3_2, 6_4]				,						in_channels=3				,						out_channels=3				,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']				,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']				,						latent_channels=4				,						)
								return model



			@property
			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								torch.manual_seed(0   )
								__a		 =       CLIPTextConfig(
								    bos_token_id=0				,						eos_token_id=2				,						hidden_size=3_2				,						intermediate_size=3_7				,						layer_norm_eps=1e-05				,						num_attention_heads=4				,						num_hidden_layers=5				,						pad_token_id=1				,						vocab_size=1_0_0_0				,						hidden_act='gelu'				,						projection_dim=5_1_2				,						)
								return CLIPTextModel(A__   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Any:
								__a		 =       'cpu'  # ensure determinism for the device-dependent torch.Generator
								__a		 =       self.dummy_cond_unet_upscale
								__a		 =       DDPMScheduler()
								__a		 =       DDIMScheduler(prediction_type='v_prediction'   )
								__a		 =       self.dummy_vae
								__a		 =       self.dummy_text_encoder
								__a		 =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

								__a		 =       self.dummy_image.cpu().permute(0				,						2				,						3				,						1   )[0]
								__a		 =       Image.fromarray(np.uinta(A__   )   ).convert('RGB'   ).resize((6_4, 6_4)   )

								# make sure here that pndm scheduler skips prk
								__a		 =       StableDiffusionUpscalePipeline(
								    unet=A__				,						low_res_scheduler=A__				,						scheduler=A__				,						vae=A__				,						text_encoder=A__				,						tokenizer=A__				,						max_noise_level=3_5_0				,						)
								__a		 =       sd_pipe.to(A__   )
								sd_pipe.set_progress_bar_config(disable=A__   )

								__a		 =       'A painting of a squirrel eating a burger'
								__a		 =       torch.Generator(device=A__   ).manual_seed(0   )
								__a		 =       sd_pipe(
								    [prompt]				,						image=A__				,						generator=A__				,						guidance_scale=6.0				,						noise_level=2_0				,						num_inference_steps=2				,						output_type='np'				,						)

								__a		 =       output.images

								__a		 =       torch.Generator(device=A__   ).manual_seed(0   )
								__a		 =       sd_pipe(
								    [prompt]				,						image=A__				,						generator=A__				,						guidance_scale=6.0				,						noise_level=2_0				,						num_inference_steps=2				,						output_type='np'				,						return_dict=A__				,						)[0]

								__a		 =       image[0, -3:, -3:, -1]
								__a		 =       image_from_tuple[0, -3:, -3:, -1]

								__a		 =       low_res_image.size[0] * 4
								assert image.shape == (1, expected_height_width, expected_height_width, 3)
								__a		 =       np.array([0.3_113, 0.3_910, 0.4_272, 0.4_859, 0.5_061, 0.4_652, 0.5_362, 0.5_715, 0.5_661]   )

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



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       'cpu'  # ensure determinism for the device-dependent torch.Generator
								__a		 =       self.dummy_cond_unet_upscale
								__a		 =       DDPMScheduler()
								__a		 =       DDIMScheduler(prediction_type='v_prediction'   )
								__a		 =       self.dummy_vae
								__a		 =       self.dummy_text_encoder
								__a		 =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

								__a		 =       self.dummy_image.cpu().permute(0				,						2				,						3				,						1   )[0]
								__a		 =       Image.fromarray(np.uinta(A__   )   ).convert('RGB'   ).resize((6_4, 6_4)   )

								# make sure here that pndm scheduler skips prk
								__a		 =       StableDiffusionUpscalePipeline(
								    unet=A__				,						low_res_scheduler=A__				,						scheduler=A__				,						vae=A__				,						text_encoder=A__				,						tokenizer=A__				,						max_noise_level=3_5_0				,						)
								__a		 =       sd_pipe.to(A__   )
								sd_pipe.set_progress_bar_config(disable=A__   )

								__a		 =       'A painting of a squirrel eating a burger'
								__a		 =       sd_pipe(
								    2 * [prompt]				,						image=2 * [low_res_image]				,						guidance_scale=6.0				,						noise_level=2_0				,						num_inference_steps=2				,						output_type='np'				,						)
								__a		 =       output.images
								assert image.shape[0] == 2

								__a		 =       torch.Generator(device=A__   ).manual_seed(0   )
								__a		 =       sd_pipe(
								    [prompt]				,						image=A__				,						generator=A__				,						num_images_per_prompt=2				,						guidance_scale=6.0				,						noise_level=2_0				,						num_inference_steps=2				,						output_type='np'				,						)
								__a		 =       output.images
								assert image.shape[0] == 2







			@unittest.skipIf(torch_device != 'cuda'				,						'This test requires a GPU'   )
			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       self.dummy_cond_unet_upscale
								__a		 =       DDPMScheduler()
								__a		 =       DDIMScheduler(prediction_type='v_prediction'   )
								__a		 =       self.dummy_vae
								__a		 =       self.dummy_text_encoder
								__a		 =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

								__a		 =       self.dummy_image.cpu().permute(0				,						2				,						3				,						1   )[0]
								__a		 =       Image.fromarray(np.uinta(A__   )   ).convert('RGB'   ).resize((6_4, 6_4)   )

								# put models in fp16, except vae as it overflows in fp16
								__a		 =       unet.half()
								__a		 =       text_encoder.half()

								# make sure here that pndm scheduler skips prk
								__a		 =       StableDiffusionUpscalePipeline(
								    unet=A__				,						low_res_scheduler=A__				,						scheduler=A__				,						vae=A__				,						text_encoder=A__				,						tokenizer=A__				,						max_noise_level=3_5_0				,						)
								__a		 =       sd_pipe.to(A__   )
								sd_pipe.set_progress_bar_config(disable=A__   )

								__a		 =       'A painting of a squirrel eating a burger'
								__a		 =       torch.manual_seed(0   )
								__a		 =       sd_pipe(
								    [prompt]				,						image=A__				,						generator=A__				,						num_inference_steps=2				,						output_type='np'				,						).images

								__a		 =       low_res_image.size[0] * 4
								assert image.shape == (1, expected_height_width, expected_height_width, 3)






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



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/sd2-upscale/low_res_cat.png'   )
								__a		 =       load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
								    '/upsampled_cat.npy'   )

								__a		 =       'stabilityai/stable-diffusion-x4-upscaler'
								__a		 =       StableDiffusionUpscalePipeline.from_pretrained(A__   )
								pipe.to(A__   )
								pipe.set_progress_bar_config(disable=A__   )
								pipe.enable_attention_slicing()

								__a		 =       'a cat sitting on a park bench'

								__a		 =       torch.manual_seed(0   )
								__a		 =       pipe(
								    prompt=A__				,						image=A__				,						generator=A__				,						output_type='np'				,						)
								__a		 =       output.images[0]

								assert image.shape == (5_1_2, 5_1_2, 3)
								assert np.abs(expected_image - image   ).max() < 1e-3



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/sd2-upscale/low_res_cat.png'   )
								__a		 =       load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
								    '/upsampled_cat_fp16.npy'   )

								__a		 =       'stabilityai/stable-diffusion-x4-upscaler'
								__a		 =       StableDiffusionUpscalePipeline.from_pretrained(
								    A__				,						torch_dtype=torch.floataa				,						)
								pipe.to(A__   )
								pipe.set_progress_bar_config(disable=A__   )
								pipe.enable_attention_slicing()

								__a		 =       'a cat sitting on a park bench'

								__a		 =       torch.manual_seed(0   )
								__a		 =       pipe(
								    prompt=A__				,						image=A__				,						generator=A__				,						output_type='np'				,						)
								__a		 =       output.images[0]

								assert image.shape == (5_1_2, 5_1_2, 3)
								assert np.abs(expected_image - image   ).max() < 5e-1







			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								__a		 =       load_image(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/sd2-upscale/low_res_cat.png'   )

								__a		 =       'stabilityai/stable-diffusion-x4-upscaler'
								__a		 =       StableDiffusionUpscalePipeline.from_pretrained(
								    A__				,						torch_dtype=torch.floataa				,						)
								pipe.to(A__   )
								pipe.set_progress_bar_config(disable=A__   )
								pipe.enable_attention_slicing(1   )
								pipe.enable_sequential_cpu_offload()

								__a		 =       'a cat sitting on a park bench'

								__a		 =       torch.manual_seed(0   )
								__a		 =       pipe(
								    prompt=A__				,						image=A__				,						generator=A__				,						num_inference_steps=5				,						output_type='np'				,						)

								__a		 =       torch.cuda.max_memory_allocated()
								# make sure that less than 2.9 GB is allocated
								assert mem_bytes < 2.9 * 1_0**9





from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase_    :		Tuple							=	logging.get_logger(__name__)

lowerCamelCase_    :		List[Any]							=	{
    """google/fnet-base""": """https://huggingface.co/google/fnet-base/resolve/main/config.json""",
    """google/fnet-large""": """https://huggingface.co/google/fnet-large/resolve/main/config.json"""
    # See all FNet models at https://huggingface.co/models?filter=fnet
}


class 						a__							(       __snake_case		):
			A__    :       Dict        =      'fnet'



			def __init__(						self				,						UpperCAmelCase=3_2_0_0_0				,						UpperCAmelCase=7_6_8				,						UpperCAmelCase=1_2				,						UpperCAmelCase=3_0_7_2				,						UpperCAmelCase="gelu_new"				,						UpperCAmelCase=0.1				,						UpperCAmelCase=5_1_2				,						UpperCAmelCase=4				,						UpperCAmelCase=0.02				,						UpperCAmelCase=1e-12				,						UpperCAmelCase=False				,						UpperCAmelCase=5_1_2				,						UpperCAmelCase=3				,						UpperCAmelCase=1				,						UpperCAmelCase=2				,						**UpperCAmelCase				,						)			->   Dict:
								super().__init__(pad_token_id=UpperCAmelCase				,						bos_token_id=UpperCAmelCase				,						eos_token_id=UpperCAmelCase				,						**UpperCAmelCase   )

								__a		 =       vocab_size
								__a		 =       max_position_embeddings
								__a		 =       hidden_size
								__a		 =       num_hidden_layers
								__a		 =       intermediate_size
								__a		 =       hidden_act
								__a		 =       hidden_dropout_prob
								__a		 =       initializer_range
								__a		 =       type_vocab_size
								__a		 =       layer_norm_eps
								__a		 =       use_tpu_fourier_optimizations
								__a		 =       tpu_short_seq_length




