





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 					__A   (  a			,    a			,    unittest.TestCase			):
				__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 _snake_case				(						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=UpperCAmelCase_      ,       )
								lowerCamelCase		       =DDIMParallelScheduler(
								    beta_start=0.0_0_0_8_5      ,       beta_end=0.0_1_2      ,       beta_schedule="""scaled_linear"""      ,       clip_sample=UpperCAmelCase_      ,       set_alpha_to_one=UpperCAmelCase_      ,       )
								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(UpperCAmelCase_							)
								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 _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_=0							):
								if str(UpperCAmelCase_							).startswith("""mps"""							):
												lowerCamelCase		       =torch.manual_seed(UpperCAmelCase_							)
								else:
												lowerCamelCase		       =torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
								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 _snake_case				(						self							):
								lowerCamelCase		       ="""cpu"""  # ensure determinism for the device-dependent torch.Generator
								lowerCamelCase		       =self.get_dummy_components()
								lowerCamelCase		       =StableDiffusionParadigmsPipeline(**UpperCAmelCase_							)
								lowerCamelCase		       =sd_pipe.to(UpperCAmelCase_							)
								sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)

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

								lowerCamelCase		       =np.array([0.4_7_7_3, 0.5_4_1_7, 0.4_7_2_3, 0.4_9_2_5, 0.5_6_3_1, 0.4_7_5_2, 0.5_2_4_0, 0.4_9_3_5, 0.5_0_2_3]							)

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


				def _snake_case				(						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(**UpperCAmelCase_							)
								lowerCamelCase		       =sd_pipe.to(UpperCAmelCase_							)
								sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)

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

								lowerCamelCase		       =np.array([0.3_5_7_3, 0.4_4_2_0, 0.4_9_6_0, 0.4_7_9_9, 0.3_7_9_6, 0.3_8_7_9, 0.4_8_1_9, 0.4_3_6_5, 0.4_4_6_8]							)

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


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


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


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

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

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

								lowerCamelCase		       =np.array([0.4_7_7_1, 0.5_4_2_0, 0.4_6_8_3, 0.4_9_1_8, 0.5_6_3_6, 0.4_7_2_5, 0.5_2_3_0, 0.4_9_2_3, 0.5_0_1_5]							)

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




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


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


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

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

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

								lowerCamelCase		       =np.array([0.9_6_2_2, 0.9_6_0_2, 0.9_7_4_8, 0.9_5_9_1, 0.9_6_3_0, 0.9_6_9_1, 0.9_6_6_1, 0.9_6_3_1, 0.9_7_4_1]							)

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












from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available

@dataclass
class 					__A   (  a			):
				__A            = 42


if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
							from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
							from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline





