


'''simple docstring'''





import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class 						a__					(					a_      ,  unittest.TestCase   ):





			'''simple docstring'''

			A						:				List[str]					      =			KandinskyVaaPriorPipeline
			A						:				Tuple					      =			["""prompt"""]
			A						:				int					      =			["""prompt""", """negative_prompt"""]
			A						:				Dict					      =			[
			    """num_images_per_prompt""",
			    """generator""",
			    """num_inference_steps""",
			    """latents""",
			    """negative_prompt""",
			    """guidance_scale""",
			    """output_type""",
			    """return_dict""",
			]
			A						:				Optional[Any]					      =			False
			@property
			def 					lowerCAmelCase     (  self							:			str	)      ->		int:
						return 32
			@property
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Optional[Any]:
						return 32
			@property
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		Union[str, Any]:
						return self.time_input_dim
			@property
			def 					lowerCAmelCase     (  self							:			Any	)      ->		List[str]:
						return self.time_input_dim * 4
			@property
			def 					lowerCAmelCase     (  self							:			Optional[int]	)      ->		Optional[Any]:
						return 100
			@property
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Any:
						__A=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)
						return tokenizer
			@property
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Optional[int]:
						torch.manual_seed(0	)
						__A=	CLIPTextConfig(
						    bos_token_id=0			,    eos_token_id=2			,    hidden_size=self.text_embedder_hidden_size			,    projection_dim=self.text_embedder_hidden_size			,    intermediate_size=37			,    layer_norm_eps=1E-05			,    num_attention_heads=4			,    num_hidden_layers=5			,    pad_token_id=1			,    vocab_size=1_000			,    )
						return CLIPTextModelWithProjection(a_	)
			@property
			def 					lowerCAmelCase     (  self							:			List[Any]	)      ->		Union[str, Any]:
						torch.manual_seed(0	)

						__A=	{
						    'num_attention_heads': 2,
						    'attention_head_dim': 12,
						    'embedding_dim': self.text_embedder_hidden_size,
						    'num_layers': 1,
						}

						__A=	PriorTransformer(**a_	)
						# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
						__A=	nn.Parameter(torch.ones(model.clip_std.shape	)	)
						return model
			@property
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		int:
						torch.manual_seed(0	)
						__A=	CLIPVisionConfig(
						    hidden_size=self.text_embedder_hidden_size			,    image_size=224			,    projection_dim=self.text_embedder_hidden_size			,    intermediate_size=37			,    num_attention_heads=4			,    num_channels=3			,    num_hidden_layers=5			,    patch_size=14			,    )

						__A=	CLIPVisionModelWithProjection(a_	)
						return model
			@property
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		List[str]:
						__A=	CLIPImageProcessor(
						    crop_size=224			,    do_center_crop=a_			,    do_normalize=a_			,    do_resize=a_			,    image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]			,    image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]			,    resample=3			,    size=224			,    )

						return image_processor
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		List[Any]:
						__A=	self.dummy_prior
						__A=	self.dummy_image_encoder
						__A=	self.dummy_text_encoder
						__A=	self.dummy_tokenizer
						__A=	self.dummy_image_processor

						__A=	UnCLIPScheduler(
						    variance_type='fixed_small_log'			,    prediction_type='sample'			,    num_train_timesteps=1_000			,    clip_sample=a_			,    clip_sample_range=10.0			,    )

						__A=	{
						    'prior': prior,
						    'image_encoder': image_encoder,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						    'scheduler': scheduler,
						    'image_processor': image_processor,
						}

						return components
			def 					lowerCAmelCase     (  self							:			Tuple			,    lowerCAmelCase_							:			Optional[Any]			,    lowerCAmelCase_							:			int=0	)      ->		List[str]:
						if str(a_	).startswith('mps'	):
									__A=	torch.manual_seed(a_	)
						else:
									__A=	torch.Generator(device=a_	).manual_seed(a_	)
						__A=	{
						    'prompt': 'horse',
						    'generator': generator,
						    'guidance_scale': 4.0,
						    'num_inference_steps': 2,
						    'output_type': 'np',
						}
						return inputs
			def 					lowerCAmelCase     (  self							:			Optional[int]	)      ->		Optional[int]:
						__A=	'cpu'

						__A=	self.get_dummy_components()

						__A=	self.pipeline_class(**a_	)
						__A=	pipe.to(a_	)

						pipe.set_progress_bar_config(disable=a_	)

						__A=	pipe(**self.get_dummy_inputs(a_	)	)
						__A=	output.image_embeds

						__A=	pipe(
						    **self.get_dummy_inputs(a_	)			,    return_dict=a_			,    )[0]

						__A=	image[0, -10:]
						__A=	image_from_tuple[0, -10:]

						assert image.shape == (1, 32)

						__A=	np.array(
						    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]	)

						assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1E-2
			@skip_mps
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		Union[str, Any]:
						__A=	torch_device == 'cpu'
						__A=	True
						__A=	False

						self._test_inference_batch_single_identical(
						    test_max_difference=a_			,    relax_max_difference=a_			,    test_mean_pixel_difference=a_			,    )

			@skip_mps
			def 					lowerCAmelCase     (  self							:			List[Any]	)      ->		int:
						__A=	torch_device == 'cpu'
						__A=	False

						self._test_attention_slicing_forward_pass(
						    test_max_difference=a_			,    test_mean_pixel_difference=a_			,    )








'''simple docstring'''

import unittest

from knapsack import knapsack as k






class 						a_		(     unittest.TestCase    ):


							def    UpperCamelCase     (				self   :						str			)			->					List[Any]:
										snake_case:    Optional[Any]      							=0
										snake_case:    List[str]      							=[0]
										snake_case:    List[str]      							=[0]
										snake_case:    Union[str, Any]      							=len(a_			)
										self.assertEqual(k.knapsack(a_      ,						a_      ,						a_      ,						a_			)      ,						0			)

										snake_case:    Union[str, Any]      							=[6_0]
										snake_case:    str      							=[1_0]
										snake_case:    List[str]      							=len(a_			)
										self.assertEqual(k.knapsack(a_      ,						a_      ,						a_      ,						a_			)      ,						0			)


							def    UpperCamelCase     (				self   :						int			)			->					Optional[Any]:
										snake_case:    Optional[int]      							=3
										snake_case:    Dict      							=[1, 2, 3]
										snake_case:    List[Any]      							=[3, 2, 1]
										snake_case:    Tuple      							=len(a_			)
										self.assertEqual(k.knapsack(a_      ,						a_      ,						a_      ,						a_			)      ,						5			)




							def    UpperCamelCase     (				self   :						List[str]			)			->					str:
										snake_case:    Any      							=5_0
										snake_case:    str      							=[6_0, 1_0_0, 1_2_0]
										snake_case:    Any      							=[1_0, 2_0, 3_0]
										snake_case:    Tuple      							=len(a_			)
										self.assertEqual(k.knapsack(a_      ,						a_      ,						a_      ,						a_			)      ,						2_2_0			)


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




