





import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class 					__lowerCAmelCase       (			_UpperCAmelCase,     _UpperCAmelCase,     _UpperCAmelCase,     unittest.TestCase     ):
			lowerCamelCase_     :     int       			=      StableUnCLIPPipeline
			lowerCamelCase_     :     str       			=      TEXT_TO_IMAGE_PARAMS
			lowerCamelCase_     :     int       			=      TEXT_TO_IMAGE_BATCH_PARAMS
			lowerCamelCase_     :     List[Any]       			=      TEXT_TO_IMAGE_IMAGE_PARAMS
			lowerCamelCase_     :     Optional[int]       			=      TEXT_TO_IMAGE_IMAGE_PARAMS

			# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
			lowerCamelCase_     :     Dict       			=      False






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  32
							snake_case_						:    int				=  embedder_hidden_size

							# prior components

							torch.manual_seed(0    )
							snake_case_						:    Any				=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

							torch.manual_seed(0    )
							snake_case_						:    str				=  CLIPTextModelWithProjection(
							    CLIPTextConfig(
							        bos_token_id=0					,							eos_token_id=2					,							hidden_size=SCREAMING_SNAKE_CASE_					,							projection_dim=SCREAMING_SNAKE_CASE_					,							intermediate_size=37					,							layer_norm_eps=1e-05					,							num_attention_heads=4					,							num_hidden_layers=5					,							pad_token_id=1					,							vocab_size=1000					,							)    )

							torch.manual_seed(0    )
							snake_case_						:    Optional[int]				=  PriorTransformer(
							    num_attention_heads=2					,							attention_head_dim=12					,							embedding_dim=SCREAMING_SNAKE_CASE_					,							num_layers=1					,							)

							torch.manual_seed(0    )
							snake_case_						:    Tuple				=  DDPMScheduler(
							    variance_type='''fixed_small_log'''					,							prediction_type='''sample'''					,							num_train_timesteps=1000					,							clip_sample=SCREAMING_SNAKE_CASE_					,							clip_sample_range=5.0					,							beta_schedule='''squaredcos_cap_v2'''					,							)

							# regular denoising components

							torch.manual_seed(0    )
							snake_case_						:    Optional[Any]				=  StableUnCLIPImageNormalizer(embedding_dim=SCREAMING_SNAKE_CASE_    )
							snake_case_						:    Any				=  DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''    )

							torch.manual_seed(0    )
							snake_case_						:    Any				=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

							torch.manual_seed(0    )
							snake_case_						:    Optional[int]				=  CLIPTextModel(
							    CLIPTextConfig(
							        bos_token_id=0					,							eos_token_id=2					,							hidden_size=SCREAMING_SNAKE_CASE_					,							projection_dim=32					,							intermediate_size=37					,							layer_norm_eps=1e-05					,							num_attention_heads=4					,							num_hidden_layers=5					,							pad_token_id=1					,							vocab_size=1000					,							)    )

							torch.manual_seed(0    )
							snake_case_						:    Optional[int]				=  UNetaDConditionModel(
							    sample_size=32					,							in_channels=4					,							out_channels=4					,							down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''')					,							up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''')					,							block_out_channels=(32, 64)					,							attention_head_dim=(2, 4)					,							class_embed_type='''projection'''					,							projection_class_embeddings_input_dim=embedder_projection_dim * 2					,							cross_attention_dim=SCREAMING_SNAKE_CASE_					,							layers_per_block=1					,							upcast_attention=SCREAMING_SNAKE_CASE_					,							use_linear_projection=SCREAMING_SNAKE_CASE_					,							)

							torch.manual_seed(0    )
							snake_case_						:    Tuple				=  DDIMScheduler(
							    beta_schedule='''scaled_linear'''					,							beta_start=0.00_085					,							beta_end=0.012					,							prediction_type='''v_prediction'''					,							set_alpha_to_one=SCREAMING_SNAKE_CASE_					,							steps_offset=1					,							)

							torch.manual_seed(0    )
							snake_case_						:    List[str]				=  AutoencoderKL()

							snake_case_						:    Any				=  {
							    # prior components
							    'prior_tokenizer': prior_tokenizer,
							    'prior_text_encoder': prior_text_encoder,
							    'prior': prior,
							    'prior_scheduler': prior_scheduler,
							    # image noising components
							    'image_normalizer': image_normalizer,
							    'image_noising_scheduler': image_noising_scheduler,
							    # regular denoising components
							    'tokenizer': tokenizer,
							    'text_encoder': text_encoder,
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							}

							return components






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__=0    )     ->   str:


							'''simple docstring'''



							if str(SCREAMING_SNAKE_CASE_    ).startswith('''mps'''    ):
											snake_case_						:    str				=  torch.manual_seed(SCREAMING_SNAKE_CASE_    )
							else:
											snake_case_						:    Tuple				=  torch.Generator(device=SCREAMING_SNAKE_CASE_    ).manual_seed(SCREAMING_SNAKE_CASE_    )
							snake_case_						:    Dict				=  {
							    'prompt': 'A painting of a squirrel eating a burger',
							    'generator': generator,
							    'num_inference_steps': 2,
							    'prior_num_inference_steps': 2,
							    'output_type': 'numpy',
							}
							return inputs






			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							snake_case_						:    Optional[int]				=  torch_device == 'cpu'

							self._test_attention_slicing_forward_pass(test_max_difference=SCREAMING_SNAKE_CASE_    )






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


							'''simple docstring'''



							snake_case_						:    Union[str, Any]				=  torch_device in ['cpu', 'mps']

							self._test_inference_batch_single_identical(test_max_difference=SCREAMING_SNAKE_CASE_    )




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






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


							'''simple docstring'''



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






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    Dict				=  load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''    )

							snake_case_						:    Tuple				=  StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''					,							torch_dtype=torch.floataa    )
							pipe.to(SCREAMING_SNAKE_CASE_    )
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )
							# stable unclip will oom when integration tests are run on a V100,
							# so turn on memory savings
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							snake_case_						:    Any				=  torch.Generator(device='''cpu'''    ).manual_seed(0    )
							snake_case_						:    Union[str, Any]				=  pipe('''anime turle'''					,							generator=SCREAMING_SNAKE_CASE_					,							output_type='''np'''    )

							snake_case_						:    int				=  output.images[0]

							assert image.shape == (768, 768, 3)

							assert_mean_pixel_difference(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							snake_case_						:    Any				=  StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''					,							torch_dtype=torch.floataa    )
							snake_case_						:    Optional[int]				=  pipe.to(SCREAMING_SNAKE_CASE_    )
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							snake_case_						:    Tuple				=  pipe(
							    '''anime turtle'''					,							prior_num_inference_steps=2					,							num_inference_steps=2					,							output_type='''np'''					,							)

							snake_case_						:    Any				=  torch.cuda.max_memory_allocated()
							# make sure that less than 7 GB is allocated
							assert mem_bytes < 7 * 10**9




'''simple docstring'''



import unittest

from knapsack import knapsack as k





class    UpperCAmelCase_  (unittest.TestCase  ):





    """simple docstring"""






    def       lowercase_				(							self	)				->     Optional[Any]:
         __lowerCamelCase   :	int								=		0
         __lowerCamelCase   :	Union[str, Any]								=		[0]
         __lowerCamelCase   :	Any								=		[0]
         __lowerCamelCase   :	Union[str, Any]								=		len(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(k.knapsack(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)			,     0	)

         __lowerCamelCase   :	List[str]								=		[60]
         __lowerCamelCase   :	Union[str, Any]								=		[10]
         __lowerCamelCase   :	List[Any]								=		len(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(k.knapsack(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)			,     0	)







    def       lowercase_				(							self	)				->     List[str]:
         __lowerCamelCase   :	Optional[int]								=		3
         __lowerCamelCase   :	int								=		[1, 2, 3]
         __lowerCamelCase   :	str								=		[3, 2, 1]
         __lowerCamelCase   :	Union[str, Any]								=		len(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(k.knapsack(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)			,     5	)







    def       lowercase_				(							self	)				->     int:
         __lowerCamelCase   :	Optional[int]								=		50
         __lowerCamelCase   :	List[str]								=		[60, 1_00, 1_20]
         __lowerCamelCase   :	List[str]								=		[10, 20, 30]
         __lowerCamelCase   :	List[str]								=		len(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(k.knapsack(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)			,     2_20	)


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






