


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  _a							(    _lowercase					,						_lowercase					,						unittest.TestCase):
	_a  :  Union[str, Any]				   =							CycleDiffusionPipeline
	_a  :  int				   =							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
	    '''negative_prompt''',
	    '''height''',
	    '''width''',
	    '''negative_prompt_embeds''',
	}
	_a  :  Any				   =							PipelineTesterMixin.required_optional_params - {'''latents'''}
	_a  :  Tuple				   =							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''source_prompt'''})
	_a  :  Optional[Any]				   =							IMAGE_TO_IMAGE_IMAGE_PARAMS
	_a  :  str				   =							IMAGE_TO_IMAGE_IMAGE_PARAMS




	def 							UpperCAmelCase__( self						:		Optional[int]		)->	Optional[Any]:
			torch.manual_seed(0		)
			lowerCAmelCase__       :      Optional[int]   					= 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		, )
			lowerCAmelCase__       :      Optional[Any]   					= DDIMScheduler(
			    beta_start=0.0_0085		, beta_end=0.012		, beta_schedule='''scaled_linear'''		, num_train_timesteps=1000		, clip_sample=_SCREAMING_SNAKE_CASE		, set_alpha_to_one=_SCREAMING_SNAKE_CASE		, )
			torch.manual_seed(0		)
			lowerCAmelCase__       :      str   					= 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		)
			lowerCAmelCase__       :      List[Any]   					= CLIPTextConfig(
			    bos_token_id=0		, eos_token_id=2		, hidden_size=32		, intermediate_size=37		, layer_norm_eps=1E-05		, num_attention_heads=4		, num_hidden_layers=5		, pad_token_id=1		, vocab_size=1000		, )
			lowerCAmelCase__       :      Dict   					= CLIPTextModel(_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Union[str, Any]   					= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

			lowerCAmelCase__       :      str   					= {
			    '''unet''': unet,
			    '''scheduler''': scheduler,
			    '''vae''': vae,
			    '''text_encoder''': text_encoder,
			    '''tokenizer''': tokenizer,
			    '''safety_checker''': None,
			    '''feature_extractor''': None,
			}
			return components




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		List[str]		, _SCREAMING_SNAKE_CASE						:		Dict=0		)->	List[str]:
			lowerCAmelCase__       :      Optional[Any]   					= floats_tensor((1, 3, 32, 32)		, rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Tuple   					= image / 2 + 0.5
			if str(_SCREAMING_SNAKE_CASE		).startswith('''mps'''		):
					lowerCAmelCase__       :      Union[str, Any]   					= torch.manual_seed(_SCREAMING_SNAKE_CASE		)
			else:
					lowerCAmelCase__       :      List[str]   					= torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      str   					= {
			    '''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 							UpperCAmelCase__( self						:		str		)->	List[str]:
			lowerCAmelCase__       :      Optional[int]   					= '''cpu'''  # ensure determinism for the device-dependent torch.Generator

			lowerCAmelCase__       :      Optional[int]   					= self.get_dummy_components()
			lowerCAmelCase__       :      List[Any]   					= CycleDiffusionPipeline(**_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Dict   					= pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      Dict   					= self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Optional[int]   					= pipe(**_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Optional[int]   					= output.images

			lowerCAmelCase__       :      List[Any]   					= images[0, -3:, -3:, -1]

			assert images.shape == (1, 32, 32, 3)
			lowerCAmelCase__       :      List[Any]   					= 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 							UpperCAmelCase__( self						:		List[Any]		)->	str:
			lowerCAmelCase__       :      List[str]   					= self.get_dummy_components()
			for name, module in components.items():
					if hasattr(_SCREAMING_SNAKE_CASE		, '''half'''		):
							lowerCAmelCase__       :      List[Any]   					= module.half()
			lowerCAmelCase__       :      Optional[int]   					= CycleDiffusionPipeline(**_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      List[str]   					= self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Any   					= pipe(**_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Dict   					= output.images

			lowerCAmelCase__       :      Union[str, Any]   					= images[0, -3:, -3:, -1]

			assert images.shape == (1, 32, 32, 3)
			lowerCAmelCase__       :      int   					= 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 							UpperCAmelCase__( self						:		int		)->	Any:
			return super().test_save_load_local()




	@unittest.skip('''non-deterministic pipeline'''		)
	def 							UpperCAmelCase__( self						:		int		)->	List[str]:
			return super().test_inference_batch_single_identical()




	@skip_mps
	def 							UpperCAmelCase__( self						:		List[str]		)->	List[Any]:
			return super().test_dict_tuple_outputs_equivalent()




	@skip_mps
	def 							UpperCAmelCase__( self						:		Dict		)->	Tuple:
			return super().test_save_load_optional_components()




	@skip_mps
	def 							UpperCAmelCase__( self						:		Union[str, Any]		)->	List[Any]:
			return super().test_attention_slicing_forward_pass()





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




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




	def 							UpperCAmelCase__( self						:		Any		)->	List[str]:
			lowerCAmelCase__       :      Optional[Any]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
			    '''/cycle-diffusion/black_colored_car.png'''		)
			lowerCAmelCase__       :      Tuple   					= load_numpy(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy'''		)
			lowerCAmelCase__       :      int   					= init_image.resize((512, 512)		)

			lowerCAmelCase__       :      Any   					= '''CompVis/stable-diffusion-v1-4'''
			lowerCAmelCase__       :      Dict   					= DDIMScheduler.from_pretrained(_SCREAMING_SNAKE_CASE		, subfolder='''scheduler'''		)
			lowerCAmelCase__       :      Optional[Any]   					= CycleDiffusionPipeline.from_pretrained(
			    _SCREAMING_SNAKE_CASE		, scheduler=_SCREAMING_SNAKE_CASE		, safety_checker=_SCREAMING_SNAKE_CASE		, torch_dtype=torch.floataa		, revision='''fp16'''		)

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

			lowerCAmelCase__       :      str   					= '''A black colored car'''
			lowerCAmelCase__       :      Optional[Any]   					= '''A blue colored car'''

			lowerCAmelCase__       :      List[Any]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe(
			    prompt=_SCREAMING_SNAKE_CASE		, source_prompt=_SCREAMING_SNAKE_CASE		, image=_SCREAMING_SNAKE_CASE		, num_inference_steps=100		, eta=0.1		, strength=0.85		, guidance_scale=3		, source_guidance_scale=1		, generator=_SCREAMING_SNAKE_CASE		, output_type='''np'''		, )
			lowerCAmelCase__       :      Any   					= 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 							UpperCAmelCase__( self						:		int		)->	Any:
			lowerCAmelCase__       :      Optional[Any]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
			    '''/cycle-diffusion/black_colored_car.png'''		)
			lowerCAmelCase__       :      Union[str, Any]   					= load_numpy(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy'''		)
			lowerCAmelCase__       :      Union[str, Any]   					= init_image.resize((512, 512)		)

			lowerCAmelCase__       :      Tuple   					= '''CompVis/stable-diffusion-v1-4'''
			lowerCAmelCase__       :      Union[str, Any]   					= DDIMScheduler.from_pretrained(_SCREAMING_SNAKE_CASE		, subfolder='''scheduler'''		)
			lowerCAmelCase__       :      Dict   					= CycleDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE		, scheduler=_SCREAMING_SNAKE_CASE		, safety_checker=_SCREAMING_SNAKE_CASE		)

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

			lowerCAmelCase__       :      Dict   					= '''A black colored car'''
			lowerCAmelCase__       :      str   					= '''A blue colored car'''

			lowerCAmelCase__       :      List[str]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      List[Any]   					= pipe(
			    prompt=_SCREAMING_SNAKE_CASE		, source_prompt=_SCREAMING_SNAKE_CASE		, image=_SCREAMING_SNAKE_CASE		, num_inference_steps=100		, eta=0.1		, strength=0.85		, guidance_scale=3		, source_guidance_scale=1		, generator=_SCREAMING_SNAKE_CASE		, output_type='''np'''		, )
			lowerCAmelCase__       :      Tuple   					= output.images

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








def 					lowerCamelCase_   (	_a = 4_000_000	):




		"""simple docstring"""






		lowerCAmelCase__       :      str   					= []
		lowerCAmelCase__					,     lowerCAmelCase__       :      Optional[Any]   					= 0, 1
		while b <= n:
				if b % 2 == 0:
						even_fibs.append(_a	)
				lowerCAmelCase__					,     lowerCAmelCase__       :      Union[str, Any]   					= b, a + b
		return sum(_a	)


if __name__ == "__main__":
		print(f'''{solution() = }''')




