





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class SCREAMING_SNAKE_CASE_			(       lowercase_				,							lowercase_				,							unittest.TestCase ):





					"""simple docstring"""


					A__								=     StableDiffusionParadigmsPipeline
					A__								=     TEXT_TO_IMAGE_PARAMS
					A__								=     TEXT_TO_IMAGE_BATCH_PARAMS
					A__								=     TEXT_TO_IMAGE_IMAGE_PARAMS
					A__								=     TEXT_TO_IMAGE_IMAGE_PARAMS





					def        __magic_name__			(			self						):
										torch.manual_seed(0						)
										lowerCamelCase__      =							UNetaDConditionModel(
										    block_out_channels=(32, 64)						,	layers_per_block=2						,	sample_size=32						,	in_channels=4						,	out_channels=4						,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")						,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")						,	cross_attention_dim=32						,	attention_head_dim=(2, 4)						,	use_linear_projection=_lowerCAmelCase						,	)
										lowerCamelCase__      =							DDIMParallelScheduler(
										    beta_start=0.00_085						,	beta_end=0.012						,	beta_schedule="scaled_linear"						,	clip_sample=_lowerCAmelCase						,	set_alpha_to_one=_lowerCAmelCase						,	)
										torch.manual_seed(0						)
										lowerCamelCase__      =							AutoencoderKL(
										    block_out_channels=[32, 64]						,	in_channels=3						,	out_channels=3						,	down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]						,	up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]						,	latent_channels=4						,	sample_size=128						,	)
										torch.manual_seed(0						)
										lowerCamelCase__      =							CLIPTextConfig(
										    bos_token_id=0						,	eos_token_id=2						,	hidden_size=32						,	intermediate_size=37						,	layer_norm_eps=1E-05						,	num_attention_heads=4						,	num_hidden_layers=5						,	pad_token_id=1						,	vocab_size=1000						,	hidden_act="gelu"						,	projection_dim=512						,	)
										lowerCamelCase__      =							CLIPTextModel(_lowerCAmelCase						)
										lowerCamelCase__      =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

										lowerCamelCase__      =							{
										    "unet": unet,
										    "scheduler": scheduler,
										    "vae": vae,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "safety_checker": None,
										    "feature_extractor": None,
										}
										return components





					def        __magic_name__			(			self						,	_lowerCAmelCase						,	_lowerCAmelCase=0						):
										if str(_lowerCAmelCase						).startswith("mps"						):
															lowerCamelCase__      =							torch.manual_seed(_lowerCAmelCase						)
										else:
															lowerCamelCase__      =							torch.Generator(device=_lowerCAmelCase						).manual_seed(_lowerCAmelCase						)
										lowerCamelCase__      =							{
										    "prompt": "a photograph of an astronaut riding a horse",
										    "generator": generator,
										    "num_inference_steps": 10,
										    "guidance_scale": 6.0,
										    "output_type": "numpy",
										    "parallel": 3,
										    "debug": True,
										}
										return inputs





					def        __magic_name__			(			self						):
										lowerCamelCase__      =							"cpu"  # ensure determinism for the device-dependent torch.Generator
										lowerCamelCase__      =							self.get_dummy_components()
										lowerCamelCase__      =							StableDiffusionParadigmsPipeline(**_lowerCAmelCase						)
										lowerCamelCase__      =							sd_pipe.to(_lowerCAmelCase						)
										sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

										lowerCamelCase__      =							self.get_dummy_inputs(_lowerCAmelCase						)
										lowerCamelCase__      =							sd_pipe(**_lowerCAmelCase						).images
										lowerCamelCase__      =							image[0, -3:, -3:, -1]
										assert image.shape == (1, 64, 64, 3)

										lowerCamelCase__      =							np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]						)

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





					def        __magic_name__			(			self						):
										lowerCamelCase__      =							"cpu"  # ensure determinism for the device-dependent torch.Generator
										lowerCamelCase__      =							self.get_dummy_components()
										torch.manual_seed(0						)
										lowerCamelCase__      =							DDPMParallelScheduler()
										torch.manual_seed(0						)
										lowerCamelCase__      =							StableDiffusionParadigmsPipeline(**_lowerCAmelCase						)
										lowerCamelCase__      =							sd_pipe.to(_lowerCAmelCase						)
										sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

										lowerCamelCase__      =							self.get_dummy_inputs(_lowerCAmelCase						)
										lowerCamelCase__      =							sd_pipe(**_lowerCAmelCase						).images
										lowerCamelCase__      =							image[0, -3:, -3:, -1]
										assert image.shape == (1, 64, 64, 3)

										lowerCamelCase__      =							np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]						)

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





					def        __magic_name__			(			self						):
										super().test_inference_batch_consistent(batch_sizes=[1, 2]						)





					def        __magic_name__			(			self						):
										super().test_inference_batch_single_identical(batch_size=2						,	expected_max_diff=3E-3						)






					def        __magic_name__			(			self						):
										lowerCamelCase__      =							"cpu"  # ensure determinism for the device-dependent torch.Generator
										lowerCamelCase__      =							self.get_dummy_components()
										lowerCamelCase__      =							StableDiffusionParadigmsPipeline(**_lowerCAmelCase						)
										lowerCamelCase__      =							sd_pipe.to(_lowerCAmelCase						)
										sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

										lowerCamelCase__      =							self.get_dummy_inputs(_lowerCAmelCase						)
										lowerCamelCase__      =							"french fries"
										lowerCamelCase__      =							sd_pipe(**_lowerCAmelCase						,	negative_prompt=_lowerCAmelCase						)
										lowerCamelCase__      =							output.images
										lowerCamelCase__      =							image[0, -3:, -3:, -1]

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

										lowerCamelCase__      =							np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]						)

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

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





					"""simple docstring"""


					def        __magic_name__			(			self						):
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()





					def        __magic_name__			(			self						,	_lowerCAmelCase=0						):
										lowerCamelCase__      =							torch.Generator(device=_lowerCAmelCase						).manual_seed(_lowerCAmelCase						)
										lowerCamelCase__      =							{
										    "prompt": "a photograph of an astronaut riding a horse",
										    "generator": generator,
										    "num_inference_steps": 10,
										    "guidance_scale": 7.5,
										    "output_type": "numpy",
										    "parallel": 3,
										    "debug": True,
										}
										return inputs






					def        __magic_name__			(			self						):
										lowerCamelCase__      =							"stabilityai/stable-diffusion-2-base"
										lowerCamelCase__      =							DDIMParallelScheduler.from_pretrained(_lowerCAmelCase						,	subfolder="scheduler"						)
										lowerCamelCase__      =							StableDiffusionParadigmsPipeline.from_pretrained(_lowerCAmelCase						,	scheduler=_lowerCAmelCase						,	safety_checker=_lowerCAmelCase						)
										pipe.to(_lowerCAmelCase						)
										pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
										pipe.enable_attention_slicing()

										lowerCamelCase__      =							self.get_inputs()
										lowerCamelCase__      =							pipe(**_lowerCAmelCase						).images
										lowerCamelCase__      =							image[0, -3:, -3:, -1].flatten()

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

										lowerCamelCase__      =							np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]						)

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








def  __UpperCamelCase   (     a = 998001)			->int:

					# fetches the next number
					for number in range(n - 1,  9999,  -1):
										lowerCamelCase__      =							str(a)

										# checks whether 'str_number' is a palindrome.
										if str_number == str_number[::-1]:
															lowerCamelCase__      =							999

															# if 'number' is a product of two 3-digit numbers
															# then number is the answer otherwise fetch next number.
															while divisor != 99:
																				if (number % divisor == 0) and (len(str(number // divisor)) == 3.0):
																									return number
																				divisor -= 1
					raise ValueError("That number is larger than our acceptable range.")


if __name__ == "__main__":
						print(f"""{solution() = }""")

