



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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__					:   List[str]       =       StableDiffusionXLPipeline
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__					:   Any       =       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""")	,	attention_head_dim=(2, 4)	,	use_linear_projection=a_	,	addition_embed_type="""text_time"""	,	addition_time_embed_dim=8	,	transformer_layers_per_block=(1, 2)	,	projection_class_embeddings_input_dim=80	,	cross_attention_dim=64	,	)
											a__					   =		EulerDiscreteScheduler(
											    beta_start=0.00_085	,	beta_end=0.012	,	steps_offset=1	,	beta_schedule="""scaled_linear"""	,	timestep_spacing="""leading"""	,	)
											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=32	,	)
											a__					   =		CLIPTextModel(a_		)
											a__					   =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,	local_files_only=a_		)

											a__					   =		CLIPTextModelWithProjection(a_		)
											a__					   =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,	local_files_only=a_		)

											a__					   =		{
											    """unet""": unet,
											    """scheduler""": scheduler,
											    """vae""": vae,
											    """text_encoder""": text_encoder,
											    """tokenizer""": tokenizer,
											    """text_encoder_2""": text_encoder_a,
											    """tokenizer_2""": tokenizer_a,
											    # "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 painting of a squirrel eating a burger""",
											    """generator""": generator,
											    """num_inference_steps""": 2,
											    """guidance_scale""": 5.0,
											    """output_type""": """numpy""",
											}
											return inputs


							def _a   (				self		):
											a__					   =		"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											a__					   =		self.get_dummy_components()
											a__					   =		StableDiffusionXLPipeline(**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.5_873, 0.6_128, 0.4_797, 0.5_122, 0.5_674, 0.4_639, 0.5_227, 0.5_149, 0.4_747]		)

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


							def _a   (				self		):
											a__					   =		self.get_dummy_components()
											a__					   =		StableDiffusionXLPipeline(**a_		)
											a__					   =		sd_pipe.to(a_		)
											a__					   =		sd_pipe.to(a_		)
											sd_pipe.set_progress_bar_config(disable=a_		)

											# forward without prompt embeds
											a__					   =		self.get_dummy_inputs(a_		)
											a__					   =		3 * ["""this is a negative prompt"""]
											a__					   =		negative_prompt
											a__					   =		3 * [inputs["""prompt"""]]

											a__					   =		sd_pipe(**a_		)
											a__					   =		output.images[0, -3:, -3:, -1]

											# forward with prompt embeds
											a__					   =		self.get_dummy_inputs(a_		)
											a__					   =		3 * ["""this is a negative prompt"""]
											a__					   =		3 * [inputs.pop("""prompt"""		)]

											(
											    (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      
											)					   =		sd_pipe.encode_prompt(a_	,	negative_prompt=a_		)

											a__					   =		sd_pipe(
											    **a_	,	prompt_embeds=a_	,	negative_prompt_embeds=a_	,	pooled_prompt_embeds=a_	,	negative_pooled_prompt_embeds=a_	,	)
											a__					   =		output.images[0, -3:, -3:, -1]

											# make sure that it's equal
											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1E-4


							def _a   (				self		):
											super().test_attention_slicing_forward_pass(expected_max_diff=3E-3		)







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




@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_	,	a_="cpu"	,	a_=torch.floataa	,	a_=0		):
											a__					   =		torch.Generator(device=a_		).manual_seed(a_		)
											a__					   =		np.random.RandomState(a_		).standard_normal((1, 4, 64, 64)		)
											a__					   =		torch.from_numpy(a_		).to(device=a_	,	dtype=a_		)
											a__					   =		{
											    """prompt""": """a photograph of an astronaut riding a horse""",
											    """latents""": latents,
											    """generator""": generator,
											    """num_inference_steps""": 3,
											    """guidance_scale""": 7.5,
											    """output_type""": """numpy""",
											}
											return inputs







							def _a   (				self		):
											a__					   =		DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""		)
											pipe.to(a_		)
											pipe.set_progress_bar_config(disable=a_		)

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

											assert image.shape == (1, 512, 512, 3)
											a__					   =		np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]		)
											assert np.abs(image_slice - expected_slice		).max() < 7E-3



def      __UpperCAmelCase    (  snake_case_							:		str				):



	'''simple docstring'''



	UpperCAmelCase:					Tuple 						=     str(snake_case_				).strip()
	if not bin_string:
		raise ValueError("Empty string was passed to the function"				)
	UpperCAmelCase:					List[Any] 						=     bin_string[0] == "-"
	if is_negative:
		UpperCAmelCase:					Optional[int] 						=     bin_string[1:]
	if not all(char in "01" for char in bin_string				):
		raise ValueError("Non-binary value was passed to the function"				)
	UpperCAmelCase:					List[str] 						=     0
	for char in bin_string:
		UpperCAmelCase:					Union[str, Any] 						=     2 * decimal_number + int(snake_case_				)
	return -decimal_number if is_negative else decimal_number


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

	testmod()
