'''simple docstring'''

import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
class   SCREAMING_SNAKE_CASE			(						__lowercase    ,			unittest.TestCase):







		"""simple docstring"""
		lowercase   :      str       =							ShapEPipeline
		lowercase   :      int       =							['prompt']
		lowercase   :      str       =							['prompt']
		lowercase   :      Any       =							[
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		lowercase   :      Optional[int]       =							False






		@property
		def 		UpperCamelCase__       (   self				) ->     str:
								return 32






		@property
		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								return 32






		@property
		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								return self.time_input_dim * 4






		@property
		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								return 8






		@property
		def 		UpperCamelCase__       (   self				) ->     List[str]:
								_lowerCAmelCase										=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)
								return tokenizer






		@property
		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								torch.manual_seed(0				)
								_lowerCAmelCase										=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=1000		,						)
								return CLIPTextModelWithProjection(__A				)






		@property
		def 		UpperCamelCase__       (   self				) ->     int:
								torch.manual_seed(0				)

								_lowerCAmelCase										={
								    'num_attention_heads': 2,
								    'attention_head_dim': 16,
								    'embedding_dim': self.time_input_dim,
								    'num_embeddings': 32,
								    'embedding_proj_dim': self.text_embedder_hidden_size,
								    'time_embed_dim': self.time_embed_dim,
								    'num_layers': 1,
								    'clip_embed_dim': self.time_input_dim * 2,
								    'additional_embeddings': 0,
								    'time_embed_act_fn': 'gelu',
								    'norm_in_type': 'layer',
								    'encoder_hid_proj_type': None,
								    'added_emb_type': None,
								}

								_lowerCAmelCase										=PriorTransformer(**__A				)
								return model






		@property
		def 		UpperCamelCase__       (   self				) ->     int:
								torch.manual_seed(0				)

								_lowerCAmelCase										={
								    'param_shapes': (
								        (self.renderer_dim, 93),
								        (self.renderer_dim, 8),
								        (self.renderer_dim, 8),
								        (self.renderer_dim, 8),
								    ),
								    'd_latent': self.time_input_dim,
								    'd_hidden': self.renderer_dim,
								    'n_output': 12,
								    'background': (
								        0.1,
								        0.1,
								        0.1,
								    ),
								}
								_lowerCAmelCase										=ShapERenderer(**__A				)
								return model






		def 		UpperCamelCase__       (   self				) ->     int:
								_lowerCAmelCase										=self.dummy_prior
								_lowerCAmelCase										=self.dummy_text_encoder
								_lowerCAmelCase										=self.dummy_tokenizer
								_lowerCAmelCase										=self.dummy_renderer

								_lowerCAmelCase										=HeunDiscreteScheduler(
								    beta_schedule='exp'		,						num_train_timesteps=1024		,						prediction_type='sample'		,						use_karras_sigmas=__A		,						clip_sample=__A		,						clip_sample_range=1.0		,						)
								_lowerCAmelCase										={
								    'prior': prior,
								    'text_encoder': text_encoder,
								    'tokenizer': tokenizer,
								    'renderer': renderer,
								    'scheduler': scheduler,
								}

								return components






		def 		UpperCamelCase__       (   self		,						__A		,						__A=0				) ->     Dict:
								if str(__A				).startswith('mps'				):
														_lowerCAmelCase										=torch.manual_seed(__A				)
								else:
														_lowerCAmelCase										=torch.Generator(device=__A				).manual_seed(__A				)
								_lowerCAmelCase										={
								    'prompt': 'horse',
								    'generator': generator,
								    'num_inference_steps': 1,
								    'frame_size': 32,
								    'output_type': 'np',
								}
								return inputs






		def 		UpperCamelCase__       (   self				) ->     int:
								_lowerCAmelCase										='cpu'

								_lowerCAmelCase										=self.get_dummy_components()

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

								pipe.set_progress_bar_config(disable=__A				)

								_lowerCAmelCase										=pipe(**self.get_dummy_inputs(__A				)				)
								_lowerCAmelCase										=output.images[0]
								_lowerCAmelCase										=image[0, -3:, -3:, -1]

								assert image.shape == (20, 32, 32, 3)

								_lowerCAmelCase										=np.array(
								    [
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								        0.00_039_216,
								    ]				)

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






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
								self._test_inference_batch_consistent(batch_sizes=[1, 2]				)






		def 		UpperCamelCase__       (   self				) ->     int:
								_lowerCAmelCase										=torch_device == 'cpu'
								_lowerCAmelCase										=True

								self._test_inference_batch_single_identical(
								    batch_size=2		,						test_max_difference=__A		,						relax_max_difference=__A		,						)






		def 		UpperCamelCase__       (   self				) ->     Dict:
								_lowerCAmelCase										=self.get_dummy_components()
								_lowerCAmelCase										=self.pipeline_class(**__A				)
								_lowerCAmelCase										=pipe.to(__A				)
								pipe.set_progress_bar_config(disable=__A				)

								_lowerCAmelCase										=1
								_lowerCAmelCase										=2

								_lowerCAmelCase										=self.get_dummy_inputs(__A				)

								for key in inputs.keys():
														if key in self.batch_params:
																				_lowerCAmelCase										=batch_size * [inputs[key]]

								_lowerCAmelCase										=pipe(**__A		,						num_images_per_prompt=__A				)[0]

								assert images.shape[0] == batch_size * num_images_per_prompt

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







		"""simple docstring"""






		def 		UpperCamelCase__       (   self				) ->     Union[str, Any]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






		def 		UpperCamelCase__       (   self				) ->     Tuple:
								_lowerCAmelCase										=load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
								    '/shap_e/test_shap_e_np_out.npy'				)
								_lowerCAmelCase										=ShapEPipeline.from_pretrained('openai/shap-e'				)
								_lowerCAmelCase										=pipe.to(__A				)
								pipe.set_progress_bar_config(disable=__A				)

								_lowerCAmelCase										=torch.Generator(device=__A				).manual_seed(0				)

								_lowerCAmelCase										=pipe(
								    'a shark'		,						generator=__A		,						guidance_scale=15.0		,						num_inference_steps=64		,						frame_size=64		,						output_type='np'		,						).images[0]

								assert images.shape == (20, 64, 64, 3)

								assert_mean_pixel_difference(__A		,						__A				)






'''simple docstring'''

import unittest

from knapsack import knapsack as k
class   SCREAMING_SNAKE_CASE			(						unittest.TestCase):







		"""simple docstring"""






		def 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								_lowerCAmelCase										=0
								_lowerCAmelCase										=[0]
								_lowerCAmelCase										=[0]
								_lowerCAmelCase										=len(__A				)
								self.assertEqual(k.knapsack(__A		,						__A		,						__A		,						__A				)		,						0				)

								_lowerCAmelCase										=[60]
								_lowerCAmelCase										=[10]
								_lowerCAmelCase										=len(__A				)
								self.assertEqual(k.knapsack(__A		,						__A		,						__A		,						__A				)		,						0				)






		def 		UpperCamelCase__       (   self				) ->     Tuple:
								_lowerCAmelCase										=3
								_lowerCAmelCase										=[1, 2, 3]
								_lowerCAmelCase										=[3, 2, 1]
								_lowerCAmelCase										=len(__A				)
								self.assertEqual(k.knapsack(__A		,						__A		,						__A		,						__A				)		,						5				)






		def 		UpperCamelCase__       (   self				) ->     Union[str, Any]:
								_lowerCAmelCase										=50
								_lowerCAmelCase										=[60, 100, 120]
								_lowerCAmelCase										=[10, 20, 30]
								_lowerCAmelCase										=len(__A				)
								self.assertEqual(k.knapsack(__A		,						__A		,						__A		,						__A				)		,						220				)


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





