



import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





def 							A			(  _UpperCAmelCase       :     str					)       ->				Dict:







			'''simple docstring'''
			_UpperCAmelCase	 =     [tensor.shape for tensor in tensor_list]
			return all(shape == shapes[0] for shape in shapes[1:]					)







class     __lowerCAmelCase					(    A       ,		A       ,		A       ,		unittest.TestCase		):
			UpperCamelCase           =  StableDiffusionLatentUpscalePipeline
			UpperCamelCase           =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
			    '''height''',
			    '''width''',
			    '''cross_attention_kwargs''',
			    '''negative_prompt_embeds''',
			    '''prompt_embeds''',
			}
			UpperCamelCase           =  PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
			UpperCamelCase           =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
			UpperCamelCase           =  frozenset(
			    []		)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
			UpperCamelCase           =  frozenset([]		)

			UpperCamelCase           =  True



			@property
			def 					_lowerCamelCase (		self     :						List[Any])     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     1
						_UpperCAmelCase	 =     4
						_UpperCAmelCase	 =     (16, 16)

						_UpperCAmelCase	 =     floats_tensor((batch_size, num_channels) + sizes				,	rng=random.Random(0)).to(A)
						return image



			def 					_lowerCamelCase (		self     :						str)     ->					List[str]:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase	 =     UNetaDConditionModel(
						    act_fn='gelu'				,	attention_head_dim=8				,	norm_num_groups=A				,	block_out_channels=[32, 32, 64, 64]				,	time_cond_proj_dim=1_60				,	conv_in_kernel=1				,	conv_out_kernel=1				,	cross_attention_dim=32				,	down_block_types=(
						        'KDownBlock2D',
						        'KCrossAttnDownBlock2D',
						        'KCrossAttnDownBlock2D',
						        'KCrossAttnDownBlock2D',
						    )				,	in_channels=8				,	mid_block_type=A				,	only_cross_attention=A				,	out_channels=5				,	resnet_time_scale_shift='scale_shift'				,	time_embedding_type='fourier'				,	timestep_post_act='gelu'				,	up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')				,	)
						_UpperCAmelCase	 =     AutoencoderKL(
						    block_out_channels=[32, 32, 64, 64]				,	in_channels=3				,	out_channels=3				,	down_block_types=[
						        'DownEncoderBlock2D',
						        'DownEncoderBlock2D',
						        'DownEncoderBlock2D',
						        'DownEncoderBlock2D',
						    ]				,	up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']				,	latent_channels=4				,	)
						_UpperCAmelCase	 =     EulerDiscreteScheduler(prediction_type='sample')
						_UpperCAmelCase	 =     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=10_00				,	hidden_act='quick_gelu'				,	projection_dim=5_12				,	)
						_UpperCAmelCase	 =     CLIPTextModel(A)
						_UpperCAmelCase	 =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

						_UpperCAmelCase	 =     {
						    'unet': model.eval(),
						    'vae': vae.eval(),
						    'scheduler': scheduler,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						}

						return components



			def 					_lowerCamelCase (		self     :						List[Any]				,	A     :						Union[str, Any]				,	A     :						List[Any]=0)     ->					List[str]:



						"""simple docstring"""






						if str(A).startswith('mps'):
									_UpperCAmelCase	 =     torch.manual_seed(A)
						else:
									_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(A)
						_UpperCAmelCase	 =     {
						    'prompt': 'A painting of a squirrel eating a burger',
						    'image': self.dummy_image.cpu(),
						    'generator': generator,
						    'num_inference_steps': 2,
						    'output_type': 'numpy',
						}
						return inputs



			def 					_lowerCamelCase (		self     :						List[Any])     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     'cpu'

						_UpperCAmelCase	 =     self.get_dummy_components()
						_UpperCAmelCase	 =     self.pipeline_class(**A)
						pipe.to(A)
						pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     self.get_dummy_inputs(A)
						_UpperCAmelCase	 =     pipe(**A).images
						_UpperCAmelCase	 =     image[0, -3:, -3:, -1]

						self.assertEqual(image.shape				,	(1, 2_56, 2_56, 3))
						_UpperCAmelCase	 =     np.array(
						    [0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5])
						_UpperCAmelCase	 =     np.abs(image_slice.flatten() - expected_slice).max()
						self.assertLessEqual(A				,	1E-3)



			def 					_lowerCamelCase (		self     :						Dict)     ->					Any:



						"""simple docstring"""






						super().test_attention_slicing_forward_pass(expected_max_diff=7E-3)



			def 					_lowerCamelCase (		self     :						Any)     ->					Tuple:



						"""simple docstring"""






						super().test_cpu_offload_forward_pass(expected_max_diff=3E-3)



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



						"""simple docstring"""






						super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3)



			def 					_lowerCamelCase (		self     :						Any)     ->					int:



						"""simple docstring"""






						super().test_inference_batch_single_identical(expected_max_diff=7E-3)



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



						"""simple docstring"""






						super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3E-3)



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



						"""simple docstring"""






						super().test_save_load_local(expected_max_difference=3E-3)



			def 					_lowerCamelCase (		self     :						Any)     ->					List[Any]:



						"""simple docstring"""






						super().test_save_load_optional_components(expected_max_difference=3E-3)



			def 					_lowerCamelCase (		self     :						str)     ->					Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     [
						    'DDIMScheduler',
						    'DDPMScheduler',
						    'PNDMScheduler',
						    'HeunDiscreteScheduler',
						    'EulerAncestralDiscreteScheduler',
						    'KDPM2DiscreteScheduler',
						    'KDPM2AncestralDiscreteScheduler',
						    'DPMSolverSDEScheduler',
						]
						_UpperCAmelCase	 =     self.get_dummy_components()
						_UpperCAmelCase	 =     self.pipeline_class(**A)

						# make sure that PNDM does not need warm-up
						pipe.scheduler.register_to_config(skip_prk_steps=A)

						pipe.to(A)
						pipe.set_progress_bar_config(disable=A)
						_UpperCAmelCase	 =     self.get_dummy_inputs(A)
						_UpperCAmelCase	 =     2

						_UpperCAmelCase	 =     []
						for scheduler_enum in KarrasDiffusionSchedulers:
									if scheduler_enum.name in skip_schedulers:
												# no sigma schedulers are not supported
												# no schedulers
												continue

									_UpperCAmelCase	 =     getattr(A				,	scheduler_enum.name)
									_UpperCAmelCase	 =     scheduler_cls.from_config(pipe.scheduler.config)
									_UpperCAmelCase	 =     pipe(**A)[0]
									outputs.append(A)

						assert check_same_shape(A)







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



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Optional[int]:



						"""simple docstring"""






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



			def 					_lowerCamelCase (		self     :						Tuple)     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     torch.manual_seed(33)

						_UpperCAmelCase	 =     StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'				,	torch_dtype=torch.floataa)
						pipe.to('cuda')

						_UpperCAmelCase	 =     StableDiffusionLatentUpscalePipeline.from_pretrained(
						    'stabilityai/sd-x2-latent-upscaler'				,	torch_dtype=torch.floataa)
						upscaler.to('cuda')

						_UpperCAmelCase	 =     'a photo of an astronaut high resolution, unreal engine, ultra realistic'

						_UpperCAmelCase	 =     pipe(A				,	generator=A				,	output_type='latent').images

						_UpperCAmelCase	 =     upscaler(
						    prompt=A				,	image=A				,	num_inference_steps=20				,	guidance_scale=0				,	generator=A				,	output_type='np'				,	).images[0]

						_UpperCAmelCase	 =     load_numpy(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy')
						assert np.abs((expected_image - image).mean()) < 5E-2



			def 					_lowerCamelCase (		self     :						Dict)     ->					List[str]:



						"""simple docstring"""






						_UpperCAmelCase	 =     torch.manual_seed(33)

						_UpperCAmelCase	 =     StableDiffusionLatentUpscalePipeline.from_pretrained(
						    'stabilityai/sd-x2-latent-upscaler'				,	torch_dtype=torch.floataa)
						upscaler.to('cuda')

						_UpperCAmelCase	 =     'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'

						_UpperCAmelCase	 =     load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png')

						_UpperCAmelCase	 =     upscaler(
						    prompt=A				,	image=A				,	num_inference_steps=20				,	guidance_scale=0				,	generator=A				,	output_type='np'				,	).images[0]

						_UpperCAmelCase	 =     load_numpy(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy')
						assert np.abs((expected_image - image).max()) < 5E-2





import unittest

from knapsack import knapsack as k







class     __lowerCAmelCase					(    unittest.TestCase		):



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



						"""simple docstring"""






						_UpperCAmelCase	 =     0
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)

						_UpperCAmelCase	 =     [60]
						_UpperCAmelCase	 =     [10]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)



			def 					_lowerCamelCase (		self     :						str)     ->					List[str]:



						"""simple docstring"""






						_UpperCAmelCase	 =     3
						_UpperCAmelCase	 =     [1, 2, 3]
						_UpperCAmelCase	 =     [3, 2, 1]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	5)



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Tuple:



						"""simple docstring"""






						_UpperCAmelCase	 =     50
						_UpperCAmelCase	 =     [60, 1_00, 1_20]
						_UpperCAmelCase	 =     [10, 20, 30]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	2_20)


if __name__ == "__main__":
							unittest.main()
