





import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()

class 		snake_case_   (							UpperCAmelCase_     ,     UpperCAmelCase_     ,     UpperCAmelCase_     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		StableUnCLIPImgaImgPipeline
	__UpperCamelCase   =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS
	__UpperCamelCase   =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	__UpperCamelCase   =		frozenset(
	    []						)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	__UpperCamelCase   =		frozenset([]						)




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

			'''simple docstring'''




			__lowercase											=     32
			__lowercase											=     embedder_hidden_size

			# image encoding components

			__lowercase											=     CLIPImageProcessor(crop_size=32					,      size=32   )

			torch.manual_seed(0   )
			__lowercase											=     CLIPVisionModelWithProjection(
			    CLIPVisionConfig(
			        hidden_size=__lowerCamelCase					,      projection_dim=__lowerCamelCase					,      num_hidden_layers=5					,      num_attention_heads=4					,      image_size=32					,      intermediate_size=37					,      patch_size=1					,      )   )

			# regular denoising components

			torch.manual_seed(0   )
			__lowercase											=     StableUnCLIPImageNormalizer(embedding_dim=__lowerCamelCase   )
			__lowercase											=     DDPMScheduler(beta_schedule='squaredcos_cap_v2'   )

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

			torch.manual_seed(0   )
			__lowercase											=     CLIPTextModel(
			    CLIPTextConfig(
			        bos_token_id=0					,      eos_token_id=2					,      hidden_size=__lowerCamelCase					,      projection_dim=32					,      intermediate_size=37					,      layer_norm_eps=1E-0_5					,      num_attention_heads=4					,      num_hidden_layers=5					,      pad_token_id=1					,      vocab_size=1_000					,      )   )

			torch.manual_seed(0   )
			__lowercase											=     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=__lowerCamelCase					,      layers_per_block=1					,      upcast_attention=__lowerCamelCase					,      use_linear_projection=__lowerCamelCase					,      )

			torch.manual_seed(0   )
			__lowercase											=     DDIMScheduler(
			    beta_schedule='scaled_linear'					,      beta_start=0.00085					,      beta_end=0.012					,      prediction_type='v_prediction'					,      set_alpha_to_one=__lowerCamelCase					,      steps_offset=1					,      )

			torch.manual_seed(0   )
			__lowercase											=     AutoencoderKL()

			__lowercase											=     {
			    # image encoding components
			    'feature_extractor': feature_extractor,
			    'image_encoder': image_encoder.eval(),
			    # image noising components
			    'image_normalizer': image_normalizer.eval(),
			    'image_noising_scheduler': image_noising_scheduler,
			    # regular denoising components
			    'tokenizer': tokenizer,
			    'text_encoder': text_encoder.eval(),
			    'unet': unet.eval(),
			    'scheduler': scheduler,
			    'vae': vae.eval(),
			}

			return components




	def    UpperCAmelCase			(						self							:     Dict					,      __lowerCamelCase							:     List[str]					,      __lowerCamelCase							:     List[Any]=0					,      __lowerCamelCase							:     int=True   )       -> Optional[int]:

			'''simple docstring'''




			if str(__lowerCamelCase   ).startswith('mps'   ):
					__lowercase											=     torch.manual_seed(__lowerCamelCase   )
			else:
					__lowercase											=     torch.Generator(device=__lowerCamelCase   ).manual_seed(__lowerCamelCase   )

			__lowercase											=     floats_tensor((1, 3, 32, 32)					,      rng=random.Random(__lowerCamelCase   )   ).to(__lowerCamelCase   )

			if pil_image:
					__lowercase											=     input_image * 0.5 + 0.5
					__lowercase											=     input_image.clamp(0					,      1   )
					__lowercase											=     input_image.cpu().permute(0					,      2					,      3					,      1   ).float().numpy()
					__lowercase											=     DiffusionPipeline.numpy_to_pil(__lowerCamelCase   )[0]

			return {
			    "prompt": "An anime racoon running a marathon",
			    "image": input_image,
			    "generator": generator,
			    "num_inference_steps": 2,
			    "output_type": "np",
			}




	@skip_mps
	def    UpperCAmelCase			(						self							:     int   )       -> int:

			'''simple docstring'''




			__lowercase											=     'cpu'  # ensure determinism for the device-dependent torch.Generator
			__lowercase											=     self.get_dummy_components()
			__lowercase											=     StableUnCLIPImgaImgPipeline(**__lowerCamelCase   )
			__lowercase											=     sd_pipe.to(__lowerCamelCase   )
			sd_pipe.set_progress_bar_config(disable=__lowerCamelCase   )

			__lowercase											=     self.get_dummy_inputs(__lowerCamelCase   )
			inputs.update({'image_embeds': None}   )
			__lowercase											=     sd_pipe(**__lowerCamelCase   ).images
			__lowercase											=     image[0, -3:, -3:, -1]

			assert image.shape == (1, 32, 32, 3)
			__lowercase											=     np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078]   )

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




	def    UpperCAmelCase			(						self							:     Union[str, Any]   )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     torch_device in ['cpu', 'mps']

			self._test_attention_slicing_forward_pass(test_max_difference=__lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Optional[Any]   )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     torch_device in ['cpu', 'mps']

			self._test_inference_batch_single_identical(test_max_difference=__lowerCamelCase   )






	@unittest.skipIf(
	    torch_device != 'cuda' or not is_xformers_available()					,      reason='XFormers attention is only available with CUDA and `xformers` installed'					,      )
	def    UpperCAmelCase			(						self							:     str   )       -> Union[str, Any]:

			'''simple docstring'''




			self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__lowerCamelCase   )





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







	'''simple docstring'''




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

			'''simple docstring'''




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




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

			'''simple docstring'''




			__lowercase											=     load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

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

			__lowercase											=     StableUnCLIPImgaImgPipeline.from_pretrained(
			    'fusing/stable-unclip-2-1-l-img2img'					,      torch_dtype=torch.floataa   )
			pipe.to(__lowerCamelCase   )
			pipe.set_progress_bar_config(disable=__lowerCamelCase   )
			# 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()

			__lowercase											=     torch.Generator(device='cpu'   ).manual_seed(0   )
			__lowercase											=     pipe(__lowerCamelCase					,      'anime turle'					,      generator=__lowerCamelCase					,      output_type='np'   )

			__lowercase											=     output.images[0]

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

			assert_mean_pixel_difference(__lowerCamelCase					,      __lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Tuple   )       -> List[str]:

			'''simple docstring'''




			__lowercase											=     load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

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

			__lowercase											=     StableUnCLIPImgaImgPipeline.from_pretrained(
			    'fusing/stable-unclip-2-1-h-img2img'					,      torch_dtype=torch.floataa   )
			pipe.to(__lowerCamelCase   )
			pipe.set_progress_bar_config(disable=__lowerCamelCase   )
			# 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()

			__lowercase											=     torch.Generator(device='cpu'   ).manual_seed(0   )
			__lowercase											=     pipe(__lowerCamelCase					,      'anime turle'					,      generator=__lowerCamelCase					,      output_type='np'   )

			__lowercase											=     output.images[0]

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

			assert_mean_pixel_difference(__lowerCamelCase					,      __lowerCamelCase   )






	def    UpperCAmelCase			(						self							:     Tuple   )       -> Optional[Any]:

			'''simple docstring'''




			__lowercase											=     load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

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

			__lowercase											=     StableUnCLIPImgaImgPipeline.from_pretrained(
			    'fusing/stable-unclip-2-1-h-img2img'					,      torch_dtype=torch.floataa   )
			__lowercase											=     pipe.to(__lowerCamelCase   )
			pipe.set_progress_bar_config(disable=__lowerCamelCase   )
			pipe.enable_attention_slicing()
			pipe.enable_sequential_cpu_offload()

			__lowercase											=     pipe(
			    __lowerCamelCase					,      'anime turtle'					,      num_inference_steps=2					,      output_type='np'					,      )

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











def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case						,   snake_case							)		->    int:

		def count_of_possible_combinations(snake_case							) -> int:
				if target < 0:
						return 0
				if target == 0:
						return 1
				return sum(count_of_possible_combinations(target - item							) for item in array							)

		return count_of_possible_combinations(snake_case							)



def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case						,   snake_case							)		->    int:

		def count_of_possible_combinations_with_dp_array(
		    snake_case						,   snake_case							) -> int:
				if target < 0:
						return 0
				if target == 0:
						return 1
				if dp_array[target] != -1:
						return dp_array[target]
				__lowercase											=     sum(
				    count_of_possible_combinations_with_dp_array(target - item						,   snake_case							)
				    for item in array							)
				__lowercase											=     answer
				return answer

		__lowercase											=     [-1] * (target + 1)
		return count_of_possible_combinations_with_dp_array(snake_case						,   snake_case							)



def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case						,   snake_case							)		->    int:
		__lowercase											=     [0] * (target + 1)
		__lowercase											=     1

		for i in range(1						,   target + 1							):
				for j in range(snake_case							):
						if i - array[j] >= 0:
								dp_array[i] += dp_array[i - array[j]]

		return dp_array[target]


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		SCREAMING_SNAKE_CASE_   :      Tuple			=   3
		SCREAMING_SNAKE_CASE_   :      Dict			=   5
		SCREAMING_SNAKE_CASE_   :      Any			=   [1, 2, 5]
		print(combination_sum_iv(n, array, target))




