



import gc
import random
import unittest

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

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
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, skip_mps

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


enable_full_determinism()
class 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  Any      =			CycleDiffusionPipeline
			lowercase__      :  List[str]      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
			    """negative_prompt""",
			    """height""",
			    """width""",
			    """negative_prompt_embeds""",
			}
			lowercase__      :  Union[str, Any]      =			PipelineTesterMixin.required_optional_params - {"""latents"""}
			lowercase__      :  List[str]      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""source_prompt"""}			)
			lowercase__      :  str      =			IMAGE_TO_IMAGE_IMAGE_PARAMS
			lowercase__      :  List[str]      =			IMAGE_TO_IMAGE_IMAGE_PARAMS





			def 		snake_case__			(				self	:       Any   )						->					Union[str, Any]:
									"""simple docstring"""







									torch.manual_seed(0   )
									__lowercase					=				UNetaDConditionModel(
									    block_out_channels=(32, 64)			,     layers_per_block=2			,     sample_size=32			,     in_channels=4			,     out_channels=4			,     down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")			,     up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")			,     cross_attention_dim=32			,     )
									__lowercase					=				DDIMScheduler(
									    beta_start=0.0_0085			,     beta_end=0.012			,     beta_schedule="""scaled_linear"""			,     num_train_timesteps=1_000			,     clip_sample=lowercase			,     set_alpha_to_one=lowercase			,     )
									torch.manual_seed(0   )
									__lowercase					=				AutoencoderKL(
									    block_out_channels=[32, 64]			,     in_channels=3			,     out_channels=3			,     down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]			,     up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]			,     latent_channels=4			,     )
									torch.manual_seed(0   )
									__lowercase					=				CLIPTextConfig(
									    bos_token_id=0			,     eos_token_id=2			,     hidden_size=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			,     )
									__lowercase					=				CLIPTextModel(lowercase   )
									__lowercase					=				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   )

									__lowercase					=				{
									    """unet""": unet,
									    """scheduler""": scheduler,
									    """vae""": vae,
									    """text_encoder""": text_encoder,
									    """tokenizer""": tokenizer,
									    """safety_checker""": None,
									    """feature_extractor""": None,
									}
									return components





			def 		snake_case__			(				self	:       Tuple			,     lowercase	:       Dict			,     lowercase	:       Any=0   )						->					Any:
									"""simple docstring"""







									__lowercase					=				floats_tensor((1, 3, 32, 32)			,     rng=random.Random(lowercase   )   ).to(lowercase   )
									__lowercase					=				image / 2 + 0.5
									if str(lowercase   ).startswith("""mps"""   ):
															__lowercase					=				torch.manual_seed(lowercase   )
									else:
															__lowercase					=				torch.Generator(device=lowercase   ).manual_seed(lowercase   )
									__lowercase					=				{
									    """prompt""": """An astronaut riding an elephant""",
									    """source_prompt""": """An astronaut riding a horse""",
									    """image""": image,
									    """generator""": generator,
									    """num_inference_steps""": 2,
									    """eta""": 0.1,
									    """strength""": 0.8,
									    """guidance_scale""": 3,
									    """source_guidance_scale""": 1,
									    """output_type""": """numpy""",
									}
									return inputs





			def 		snake_case__			(				self	:       Tuple   )						->					Any:
									"""simple docstring"""







									__lowercase					=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator

									__lowercase					=				self.get_dummy_components()
									__lowercase					=				CycleDiffusionPipeline(**lowercase   )
									__lowercase					=				pipe.to(lowercase   )
									pipe.set_progress_bar_config(disable=lowercase   )

									__lowercase					=				self.get_dummy_inputs(lowercase   )
									__lowercase					=				pipe(**lowercase   )
									__lowercase					=				output.images

									__lowercase					=				images[0, -3:, -3:, -1]

									assert images.shape == (1, 32, 32, 3)
									__lowercase					=				np.array([0.4459, 0.4943, 0.4544, 0.6643, 0.5474, 0.4327, 0.5701, 0.5959, 0.5179]   )

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





			@unittest.skipIf(torch_device != """cuda"""			,     """This test requires a GPU"""   )
			def 		snake_case__			(				self	:       List[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase					=				self.get_dummy_components()
									for name, module in components.items():
															if hasattr(lowercase			,     """half"""   ):
																					__lowercase					=				module.half()
									__lowercase					=				CycleDiffusionPipeline(**lowercase   )
									__lowercase					=				pipe.to(lowercase   )
									pipe.set_progress_bar_config(disable=lowercase   )

									__lowercase					=				self.get_dummy_inputs(lowercase   )
									__lowercase					=				pipe(**lowercase   )
									__lowercase					=				output.images

									__lowercase					=				images[0, -3:, -3:, -1]

									assert images.shape == (1, 32, 32, 3)
									__lowercase					=				np.array([0.3506, 0.4543, 0.446, 0.4575, 0.5195, 0.4155, 0.5273, 0.518, 0.4116]   )

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





			@skip_mps
			def 		snake_case__			(				self	:       Optional[Any]   )						->					str:
									"""simple docstring"""







									return super().test_save_load_local()





			@unittest.skip("""non-deterministic pipeline"""   )
			def 		snake_case__			(				self	:       str   )						->					Dict:
									"""simple docstring"""







									return super().test_inference_batch_single_identical()





			@skip_mps
			def 		snake_case__			(				self	:       Tuple   )						->					List[str]:
									"""simple docstring"""







									return super().test_dict_tuple_outputs_equivalent()





			@skip_mps
			def 		snake_case__			(				self	:       List[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									return super().test_save_load_optional_components()







			@skip_mps
			def 		snake_case__			(				self	:       Union[str, Any]   )						->					Optional[Any]:
									"""simple docstring"""







									return super().test_attention_slicing_forward_pass()





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






			"""simple docstring"""





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					Tuple:
									"""simple docstring"""







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





			def 		snake_case__			(				self	:       str   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				load_image(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
									    """/cycle-diffusion/black_colored_car.png"""   )
									__lowercase					=				load_numpy(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"""   )
									__lowercase					=				init_image.resize((512, 512)   )

									__lowercase					=				"""CompVis/stable-diffusion-v1-4"""
									__lowercase					=				DDIMScheduler.from_pretrained(lowercase			,     subfolder="""scheduler"""   )
									__lowercase					=				CycleDiffusionPipeline.from_pretrained(
									    lowercase			,     scheduler=lowercase			,     safety_checker=lowercase			,     torch_dtype=torch.floataa			,     revision="""fp16"""   )

									pipe.to(lowercase   )
									pipe.set_progress_bar_config(disable=lowercase   )
									pipe.enable_attention_slicing()

									__lowercase					=				"""A black colored car"""
									__lowercase					=				"""A blue colored car"""

									__lowercase					=				torch.manual_seed(0   )
									__lowercase					=				pipe(
									    prompt=lowercase			,     source_prompt=lowercase			,     image=lowercase			,     num_inference_steps=100			,     eta=0.1			,     strength=0.85			,     guidance_scale=3			,     source_guidance_scale=1			,     generator=lowercase			,     output_type="""np"""			,     )
									__lowercase					=				output.images

									# the values aren't exactly equal, but the images look the same visually
									assert np.abs(image - expected_image   ).max() < 5E-1







			def 		snake_case__			(				self	:       Optional[int]   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				load_image(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
									    """/cycle-diffusion/black_colored_car.png"""   )
									__lowercase					=				load_numpy(
									    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"""   )
									__lowercase					=				init_image.resize((512, 512)   )

									__lowercase					=				"""CompVis/stable-diffusion-v1-4"""
									__lowercase					=				DDIMScheduler.from_pretrained(lowercase			,     subfolder="""scheduler"""   )
									__lowercase					=				CycleDiffusionPipeline.from_pretrained(lowercase			,     scheduler=lowercase			,     safety_checker=lowercase   )

									pipe.to(lowercase   )
									pipe.set_progress_bar_config(disable=lowercase   )
									pipe.enable_attention_slicing()

									__lowercase					=				"""A black colored car"""
									__lowercase					=				"""A blue colored car"""

									__lowercase					=				torch.manual_seed(0   )
									__lowercase					=				pipe(
									    prompt=lowercase			,     source_prompt=lowercase			,     image=lowercase			,     num_inference_steps=100			,     eta=0.1			,     strength=0.85			,     guidance_scale=3			,     source_guidance_scale=1			,     generator=lowercase			,     output_type="""np"""			,     )
									__lowercase					=				output.images

									assert np.abs(image - expected_image   ).max() < 2E-2










def  UpperCAmelCase__    (    lowercase__   ) ->      Optional[int]:
						__lowercase					=				len(lowercase__   )
						__lowercase					=				sum(lowercase__   )

						__lowercase					=				[[False for x in range(s + 1   )] for y in range(n + 1   )]

						for i in range(1						,       n + 1   ):
												__lowercase					=				True

						for i in range(1						,       s + 1   ):
												__lowercase					=				False

						for i in range(1						,       n + 1   ):
												for j in range(1						,       s + 1   ):
																		__lowercase					=				dp[i][j - 1]

																		if arr[i - 1] <= j:
																								__lowercase					=				dp[i][j] or dp[i - 1][j - arr[i - 1]]

						for j in range(int(s / 2   )						,       -1						,       -1   ):
												if dp[n][j] is True:
																		__lowercase					=				s - 2 * j
																		break

						return diff





