

"""simple docstring"""

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     (						UpperCamelCase						,			UpperCamelCase						,			unittest.TestCase       ):
						__snake_case 			=     StableDiffusionXLPipeline
						__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        _UpperCamelCase    (self							)			->						int:
											torch.manual_seed(0							)
											__lowercase												=			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''')     ,							attention_head_dim=(2, 4)     ,							use_linear_projection=UpperCAmelCase_     ,							addition_embed_type='''text_time'''     ,							addition_time_embed_dim=8     ,							transformer_layers_per_block=(1, 2)     ,							projection_class_embeddings_input_dim=8_0     ,							cross_attention_dim=6_4     ,							)
											__lowercase												=			EulerDiscreteScheduler(
											    beta_start=0.0_0_0_8_5     ,							beta_end=0.0_1_2     ,							steps_offset=1     ,							beta_schedule='''scaled_linear'''     ,							timestep_spacing='''leading'''     ,							)
											torch.manual_seed(0							)
											__lowercase												=			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							)
											__lowercase												=			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=3_2     ,							)
											__lowercase												=			CLIPTextModel(UpperCAmelCase_							)
											__lowercase												=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     ,							local_files_only=UpperCAmelCase_							)

											__lowercase												=			CLIPTextModelWithProjection(UpperCAmelCase_							)
											__lowercase												=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     ,							local_files_only=UpperCAmelCase_							)

											__lowercase												=			{
											    '''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        _UpperCamelCase    (self     ,							UpperCAmelCase_     ,							UpperCAmelCase_=0							)			->						str:
											if str(UpperCAmelCase_							).startswith('''mps'''							):
																__lowercase												=			torch.manual_seed(UpperCAmelCase_							)
											else:
																__lowercase												=			torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
											__lowercase												=			{
											    '''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        _UpperCamelCase    (self							)			->						Dict:
											__lowercase												=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
											__lowercase												=			self.get_dummy_components()
											__lowercase												=			StableDiffusionXLPipeline(**UpperCAmelCase_							)
											__lowercase												=			sd_pipe.to(UpperCAmelCase_							)
											sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)

											__lowercase												=			self.get_dummy_inputs(UpperCAmelCase_							)
											__lowercase												=			sd_pipe(**UpperCAmelCase_							).images
											__lowercase												=			image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowercase												=			np.array([0.5_8_7_3, 0.6_1_2_8, 0.4_7_9_7, 0.5_1_2_2, 0.5_6_7_4, 0.4_6_3_9, 0.5_2_2_7, 0.5_1_4_9, 0.4_7_4_7]							)

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







						def        _UpperCamelCase    (self							)			->						Optional[Any]:
											__lowercase												=			self.get_dummy_components()
											__lowercase												=			StableDiffusionXLPipeline(**UpperCAmelCase_							)
											__lowercase												=			sd_pipe.to(UpperCAmelCase_							)
											__lowercase												=			sd_pipe.to(UpperCAmelCase_							)
											sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)

											# forward without prompt embeds
											__lowercase												=			self.get_dummy_inputs(UpperCAmelCase_							)
											__lowercase												=			3 * ['''this is a negative prompt''']
											__lowercase												=			negative_prompt
											__lowercase												=			3 * [inputs['''prompt''']]

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

											# forward with prompt embeds
											__lowercase												=			self.get_dummy_inputs(UpperCAmelCase_							)
											__lowercase												=			3 * ['''this is a negative prompt''']
											__lowercase												=			3 * [inputs.pop('''prompt'''							)]

											(
											    (
											    __lowercase
											)						, (
											    __lowercase
											)						, (
											    __lowercase
											)						, (
											    __lowercase
											)						, 
											)												=			sd_pipe.encode_prompt(UpperCAmelCase_     ,							negative_prompt=UpperCAmelCase_							)

											__lowercase												=			sd_pipe(
											    **UpperCAmelCase_     ,							prompt_embeds=UpperCAmelCase_     ,							negative_prompt_embeds=UpperCAmelCase_     ,							pooled_prompt_embeds=UpperCAmelCase_     ,							negative_pooled_prompt_embeds=UpperCAmelCase_     ,							)
											__lowercase												=			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        _UpperCamelCase    (self							)			->						List[Any]:
											super().test_attention_slicing_forward_pass(expected_max_diff=3e-3							)







						def        _UpperCamelCase    (self							)			->						int:
											super().test_inference_batch_single_identical(expected_max_diff=3e-3							)



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







						def        _UpperCamelCase    (self							)			->						Union[str, Any]:
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()







						def        _UpperCamelCase    (self     ,							UpperCAmelCase_     ,							UpperCAmelCase_="cpu"     ,							UpperCAmelCase_=torch.floataa     ,							UpperCAmelCase_=0							)			->						Union[str, Any]:
											__lowercase												=			torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
											__lowercase												=			np.random.RandomState(UpperCAmelCase_							).standard_normal((1, 4, 6_4, 6_4)							)
											__lowercase												=			torch.from_numpy(UpperCAmelCase_							).to(device=UpperCAmelCase_     ,							dtype=UpperCAmelCase_							)
											__lowercase												=			{
											    '''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        _UpperCamelCase    (self							)			->						Union[str, Any]:
											__lowercase												=			DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''							)
											pipe.to(UpperCAmelCase_							)
											pipe.set_progress_bar_config(disable=UpperCAmelCase_							)

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowercase												=			np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]							)
											assert np.abs(image_slice - expected_slice							).max() < 7e-3





"""simple docstring"""

def 				__UpperCamelCase   (    a__: list ,	a__: list ,	a__: list ,	a__: int ,	a__: int			)				->			None:




					"""simple docstring"""



					if target == 0:
										answer.append(path.copy()			)
					else:
										for index in range(a__ ,	len(a__			)			):
															if target >= candidates[index]:
																				path.append(candidates[index]			)
																				backtrack(a__ ,	a__ ,	a__ ,	target - candidates[index] ,	a__			)
																				path.pop(len(a__			) - 1			)





def 				__UpperCamelCase   (    a__: list ,	a__: int			)				->			list:




					"""simple docstring"""



					__lowercase												=			[]  # type: list[int]
					__lowercase												=			[]  # type: list[int]
					backtrack(a__ ,	a__ ,	a__ ,	a__ ,	0			)
					return answer





def 				__UpperCamelCase   (    )				->			None:




					"""simple docstring"""



					print(combination_sum([-8, 2.3, 0] ,	1			)			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()


