



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 	__snake_case (				SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE     ,unittest.TestCase):







							'''simple docstring'''






							UpperCamelCase__			: Dict             =   StableDiffusionParadigmsPipeline
							UpperCamelCase__			: Optional[Any]             =   TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__			: List[Any]             =   TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__			: List[Any]             =   TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__			: int             =   TEXT_TO_IMAGE_IMAGE_PARAMS


							def _a (							self						):
											torch.manual_seed(0						)
											a__			 =						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=a_					,					)
											a__			 =						DDIMParallelScheduler(
											    beta_start=0.00_085					,					beta_end=0.012					,					beta_schedule="""scaled_linear"""					,					clip_sample=a_					,					set_alpha_to_one=a_					,					)
											torch.manual_seed(0						)
											a__			 =						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						)
											a__			 =						CLIPTextConfig(
											    bos_token_id=0					,					eos_token_id=2					,					hidden_size=32					,					intermediate_size=37					,					layer_norm_eps=1E-0_5					,					num_attention_heads=4					,					num_hidden_layers=5					,					pad_token_id=1					,					vocab_size=1_000					,					hidden_act="""gelu"""					,					projection_dim=512					,					)
											a__			 =						CLIPTextModel(a_						)
											a__			 =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

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


							def _a (							self					,					a_					,					a_=0						):
											if str(a_						).startswith("""mps"""						):
															a__			 =						torch.manual_seed(a_						)
											else:
															a__			 =						torch.Generator(device=a_						).manual_seed(a_						)
											a__			 =						{
											    """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 _a (							self						):
											a__			 =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											a__			 =						self.get_dummy_components()
											a__			 =						StableDiffusionParadigmsPipeline(**a_						)
											a__			 =						sd_pipe.to(a_						)
											sd_pipe.set_progress_bar_config(disable=a_						)

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

											a__			 =						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 _a (							self						):
											a__			 =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											a__			 =						self.get_dummy_components()
											torch.manual_seed(0						)
											a__			 =						DDPMParallelScheduler()
											torch.manual_seed(0						)
											a__			 =						StableDiffusionParadigmsPipeline(**a_						)
											a__			 =						sd_pipe.to(a_						)
											sd_pipe.set_progress_bar_config(disable=a_						)

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

											a__			 =						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 _a (							self						):
											super().test_inference_batch_consistent(batch_sizes=[1, 2]						)


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







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

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

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

											a__			 =						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 	__snake_case (				unittest.TestCase):







							'''simple docstring'''






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


							def _a (							self					,					a_=0						):
											a__			 =						torch.Generator(device=a_						).manual_seed(a_						)
											a__			 =						{
											    """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 _a (							self						):
											a__			 =						"""stabilityai/stable-diffusion-2-base"""
											a__			 =						DDIMParallelScheduler.from_pretrained(a_					,					subfolder="""scheduler"""						)
											a__			 =						StableDiffusionParadigmsPipeline.from_pretrained(a_					,					scheduler=a_					,					safety_checker=a_						)
											pipe.to(a_						)
											pipe.set_progress_bar_config(disable=a_						)
											pipe.enable_attention_slicing()

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

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

											a__			 =						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      A_ (		__a       :			int						):

				"""simple docstring"""
				if number != int(__a						):
								raise ValueError("""factorial() only accepts integral values"""						)
				if number < 0:
								raise ValueError("""factorial() not defined for negative values"""						)
				a__			 =						1
				for i in range(1	,						number + 1						):
								value *= i
				return value

def      A_ (		__a       :			int						):

				"""simple docstring"""
				if not isinstance(__a	,						__a						):
								raise ValueError("""factorial() only accepts integral values"""						)
				if n < 0:
								raise ValueError("""factorial() not defined for negative values"""						)
				return 1 if n == 0 or n == 1 else n * factorial(n - 1						)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	UpperCAmelCase								=   int(input("""Enter a positive integer: """).strip() or 0)
	print(f"""factorial{n} is {factorial(n)}""")

