




'''simple docstring'''





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	(			lowercase_		,		lowercase_		,		unittest.TestCase							):
			lowerCAmelCase_  :   Tuple		 =					StableDiffusionParadigmsPipeline
			lowerCAmelCase_  :   str		 =					TEXT_TO_IMAGE_PARAMS
			lowerCAmelCase_  :   Dict		 =					TEXT_TO_IMAGE_BATCH_PARAMS
			lowerCAmelCase_  :   Any		 =					TEXT_TO_IMAGE_IMAGE_PARAMS
			lowerCAmelCase_  :   Optional[Any]		 =					TEXT_TO_IMAGE_IMAGE_PARAMS




			def      lowerCAmelCase__       (      self							)       ->       Dict:

										'''simple docstring'''




										torch.manual_seed(0							)
										snake_case_			      =   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__       ,							)
										snake_case_			      =   DDIMParallelScheduler(
										    beta_start=0.0_0_0_8_5       ,							beta_end=0.0_1_2       ,							beta_schedule="scaled_linear"       ,							clip_sample=a__       ,							set_alpha_to_one=a__       ,							)
										torch.manual_seed(0							)
										snake_case_			      =   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							)
										snake_case_			      =   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=1_000       ,							hidden_act="gelu"       ,							projection_dim=512       ,							)
										snake_case_			      =   CLIPTextModel(a__							)
										snake_case_			      =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)

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




			def      lowerCAmelCase__       (      self       ,							a__       ,							a__=0							)       ->       str:

										'''simple docstring'''




										if str(a__							).startswith("mps"							):
																	snake_case_			      =   torch.manual_seed(a__							)
										else:
																	snake_case_			      =   torch.Generator(device=a__							).manual_seed(a__							)
										snake_case_			      =   {
										    "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      lowerCAmelCase__       (      self							)       ->       List[Any]:

										'''simple docstring'''




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

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

										snake_case_			      =   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      lowerCAmelCase__       (      self							)       ->       Optional[int]:

										'''simple docstring'''




										snake_case_			      =   "cpu"  # ensure determinism for the device-dependent torch.Generator
										snake_case_			      =   self.get_dummy_components()
										torch.manual_seed(0							)
										snake_case_			      =   DDPMParallelScheduler()
										torch.manual_seed(0							)
										snake_case_			      =   StableDiffusionParadigmsPipeline(**a__							)
										snake_case_			      =   sd_pipe.to(a__							)
										sd_pipe.set_progress_bar_config(disable=a__							)

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

										snake_case_			      =   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      lowerCAmelCase__       (      self							)       ->       Tuple:

										'''simple docstring'''




										super().test_inference_batch_consistent(batch_sizes=[1, 2]							)




			def      lowerCAmelCase__       (      self							)       ->       Union[str, Any]:

										'''simple docstring'''




										super().test_inference_batch_single_identical(batch_size=2       ,							expected_max_diff=3e-3							)




			def      lowerCAmelCase__       (      self							)       ->       Optional[Any]:

										'''simple docstring'''




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

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

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

										snake_case_			      =   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 				_snake_case	(			unittest.TestCase							):




			def      lowerCAmelCase__       (      self							)       ->       str:

										'''simple docstring'''




										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()




			def      lowerCAmelCase__       (      self       ,							a__=0							)       ->       Any:

										'''simple docstring'''




										snake_case_			      =   torch.Generator(device=a__							).manual_seed(a__							)
										snake_case_			      =   {
										    "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      lowerCAmelCase__       (      self							)       ->       Optional[int]:

										'''simple docstring'''




										snake_case_			      =   "stabilityai/stable-diffusion-2-base"
										snake_case_			      =   DDIMParallelScheduler.from_pretrained(a__       ,							subfolder="scheduler"							)
										snake_case_			      =   StableDiffusionParadigmsPipeline.from_pretrained(a__       ,							scheduler=a__       ,							safety_checker=a__							)
										pipe.to(a__							)
										pipe.set_progress_bar_config(disable=a__							)
										pipe.enable_attention_slicing()

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

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

										snake_case_			      =   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










'''simple docstring'''





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils




class 				_snake_case	(			unittest.TestCase							):




			@patch("diffusers.utils.hub_utils.get_full_repo_name"							)
			def      lowerCAmelCase__       (      self       ,							a__							)       ->       None:

										'''simple docstring'''




										snake_case_			      =   "full_repo_name"
										with TemporaryDirectory() as tmpdir:
																	# Dummy args values
																	snake_case_			      =   Mock()
																	snake_case_			      =   tmpdir
																	snake_case_			      =   0
																	snake_case_			      =   "hub_token"
																	snake_case_			      =   "dataset_name"
																	snake_case_			      =   0.0_1
																	snake_case_			      =   100_000
																	snake_case_			      =   10_000
																	snake_case_			      =   0.0_1
																	snake_case_			      =   0.0_2
																	snake_case_			      =   0.0_3
																	snake_case_			      =   0.0_0_0_5
																	snake_case_			      =   0.0_0_0_0_0_1
																	snake_case_			      =   1
																	snake_case_			      =   10
																	snake_case_			      =   0.0_0_1
																	snake_case_			      =   0.1
																	snake_case_			      =   0.2
																	snake_case_			      =   True

																	# Model card mush be rendered and saved
																	diffusers.utils.hub_utils.create_model_card(a__       ,							model_name="model_name"							)
																	self.assertTrue((Path(a__							) / "README.md").is_file()							)




