






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   UpperCamelCase			(					snake_case__      ,							snake_case__      ,							unittest.TestCase			):







		"""simple docstring"""



		snake_case			 = StableDiffusionParadigmsPipeline
		snake_case			 = TEXT_TO_IMAGE_PARAMS
		snake_case			 = TEXT_TO_IMAGE_BATCH_PARAMS
		snake_case			 = TEXT_TO_IMAGE_IMAGE_PARAMS
		snake_case			 = TEXT_TO_IMAGE_IMAGE_PARAMS
		def    A(	self		:							Optional[Any]		)     -> int:


						'''simple docstring'''
						torch.manual_seed(0		)
						A									=   UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)    ,layers_per_block=2    ,sample_size=3_2    ,in_channels=4    ,out_channels=4    ,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')    ,up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')    ,cross_attention_dim=3_2    ,attention_head_dim=(2, 4)    ,use_linear_projection=_SCREAMING_SNAKE_CASE    ,)
						A									=   DDIMParallelScheduler(
						    beta_start=0.00085    ,beta_end=0.012    ,beta_schedule='scaled_linear'    ,clip_sample=_SCREAMING_SNAKE_CASE    ,set_alpha_to_one=_SCREAMING_SNAKE_CASE    ,)
						torch.manual_seed(0		)
						A									=   AutoencoderKL(
						    block_out_channels=[3_2, 6_4]    ,in_channels=3    ,out_channels=3    ,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']    ,up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']    ,latent_channels=4    ,sample_size=1_2_8    ,)
						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    ,)
						A									=   CLIPTextModel(_SCREAMING_SNAKE_CASE		)
						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		:							str    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Tuple=0		)     -> Any:


						'''simple docstring'''
						if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
										A									=   torch.manual_seed(_SCREAMING_SNAKE_CASE		)
						else:
										A									=   torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
						A									=   {
						    'prompt': 'a photograph of an astronaut riding a horse',
						    'generator': generator,
						    'num_inference_steps': 1_0,
						    'guidance_scale': 6.0,
						    'output_type': 'numpy',
						    'parallel': 3,
						    'debug': True,
						}
						return inputs
		def    A(	self		:							Any		)     -> Tuple:


						'''simple docstring'''
						A									=   'cpu'  # ensure determinism for the device-dependent torch.Generator
						A									=   self.get_dummy_components()
						A									=   StableDiffusionParadigmsPipeline(**_SCREAMING_SNAKE_CASE		)
						A									=   sd_pipe.to(_SCREAMING_SNAKE_CASE		)
						sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

						A									=   self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
						A									=   sd_pipe(**_SCREAMING_SNAKE_CASE		).images
						A									=   image[0, -3:, -3:, -1]
						assert image.shape == (1, 6_4, 6_4, 3)

						A									=   np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
		def    A(	self		:							List[Any]		)     -> List[Any]:


						'''simple docstring'''
						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(**_SCREAMING_SNAKE_CASE		)
						A									=   sd_pipe.to(_SCREAMING_SNAKE_CASE		)
						sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

						A									=   self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
						A									=   sd_pipe(**_SCREAMING_SNAKE_CASE		).images
						A									=   image[0, -3:, -3:, -1]
						assert image.shape == (1, 6_4, 6_4, 3)

						A									=   np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]		)

						assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
		def    A(	self		:							Optional[int]		)     -> Any:


						'''simple docstring'''
						super().test_inference_batch_consistent(batch_sizes=[1, 2]		)
		def    A(	self		:							Dict		)     -> Dict:


						'''simple docstring'''
						super().test_inference_batch_single_identical(batch_size=2    ,expected_max_diff=3E-3		)







		def    A(	self		:							Optional[int]		)     -> int:


						'''simple docstring'''
						A									=   'cpu'  # ensure determinism for the device-dependent torch.Generator
						A									=   self.get_dummy_components()
						A									=   StableDiffusionParadigmsPipeline(**_SCREAMING_SNAKE_CASE		)
						A									=   sd_pipe.to(_SCREAMING_SNAKE_CASE		)
						sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

						A									=   self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
						A									=   'french fries'
						A									=   sd_pipe(**_SCREAMING_SNAKE_CASE    ,negative_prompt=_SCREAMING_SNAKE_CASE		)
						A									=   output.images
						A									=   image[0, -3:, -3:, -1]

						assert image.shape == (1, 6_4, 6_4, 3)

						A									=   np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]		)

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


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







		"""simple docstring"""



		def    A(	self		:							Tuple		)     -> List[Any]:


						'''simple docstring'''
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()
		def    A(	self		:							int    ,_SCREAMING_SNAKE_CASE		:							Tuple=0		)     -> str:


						'''simple docstring'''
						A									=   torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
						A									=   {
						    'prompt': 'a photograph of an astronaut riding a horse',
						    'generator': generator,
						    'num_inference_steps': 1_0,
						    'guidance_scale': 7.5,
						    'output_type': 'numpy',
						    'parallel': 3,
						    'debug': True,
						}
						return inputs







		def    A(	self		:							Any		)     -> Dict:


						'''simple docstring'''
						A									=   'stabilityai/stable-diffusion-2-base'
						A									=   DDIMParallelScheduler.from_pretrained(_SCREAMING_SNAKE_CASE    ,subfolder='scheduler'		)
						A									=   StableDiffusionParadigmsPipeline.from_pretrained(_SCREAMING_SNAKE_CASE    ,scheduler=_SCREAMING_SNAKE_CASE    ,safety_checker=_SCREAMING_SNAKE_CASE		)
						pipe.to(_SCREAMING_SNAKE_CASE		)
						pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)
						pipe.enable_attention_slicing()

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

						assert image.shape == (1, 5_1_2, 5_1_2, 3)

						A									=   np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]		)

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













def   snake_case		(				UpperCAmelCase						:							set,    UpperCAmelCase						:							set ):
				assert isinstance(UpperCAmelCase,    UpperCAmelCase ), f'The input value of [set_a={set_a}] is not a set'
				assert isinstance(UpperCAmelCase,    UpperCAmelCase ), f'The input value of [set_b={set_b}] is not a set'

				return {a + b for a in set_a for b in set_b}


if __name__ == "__main__":
					from doctest import testmod

					testmod()





