




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 					__magic_name__							( UpperCAmelCase__		,      UpperCAmelCase__		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		CycleDiffusionPipeline
				__UpperCamelCase    						=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
				    "negative_prompt",
				    "height",
				    "width",
				    "negative_prompt_embeds",
				}
				__UpperCamelCase    						=		PipelineTesterMixin.required_optional_params - {"latents"}
				__UpperCamelCase    						=		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"source_prompt"}       )
				__UpperCamelCase    						=		IMAGE_TO_IMAGE_IMAGE_PARAMS
				__UpperCamelCase    						=		IMAGE_TO_IMAGE_IMAGE_PARAMS





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							torch.manual_seed(0				)
							lowerCamelCase       =      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       =      DDIMScheduler(
							    beta_start=0.00_085	,				beta_end=0.012	,				beta_schedule="""scaled_linear"""	,				num_train_timesteps=1_000	,				clip_sample=_a	,				set_alpha_to_one=_a	,				)
							torch.manual_seed(0				)
							lowerCamelCase       =      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       =      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	,				)
							lowerCamelCase       =      CLIPTextModel(_a				)
							lowerCamelCase       =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

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





				def      _lowerCAmelCase       ( self	,				_a	,				_a=0				):





							"""simple docstring"""
							lowerCamelCase       =      floats_tensor((1, 3, 32, 32)	,				rng=random.Random(_a				)				).to(_a				)
							lowerCamelCase       =      image / 2 + 0.5
							if str(_a				).startswith("""mps"""				):
										lowerCamelCase       =      torch.manual_seed(_a				)
							else:
										lowerCamelCase       =      torch.Generator(device=_a				).manual_seed(_a				)
							lowerCamelCase       =      {
							    """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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """cpu"""  # ensure determinism for the device-dependent torch.Generator

							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      CycleDiffusionPipeline(**_a				)
							lowerCamelCase       =      pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      pipe(**_a				)
							lowerCamelCase       =      output.images

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

							assert images.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.4_459, 0.4_943, 0.4_544, 0.6_643, 0.5_474, 0.4_327, 0.5_701, 0.5_959, 0.5_179]				)

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





				@unittest.skipIf(torch_device != """cuda"""	,				"""This test requires a GPU"""				)
				def      _lowerCAmelCase       ( self				):





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

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      pipe(**_a				)
							lowerCamelCase       =      output.images

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

							assert images.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.3_506, 0.4_543, 0.446, 0.4_575, 0.5_195, 0.4_155, 0.5_273, 0.518, 0.4_116]				)

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





				@skip_mps
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return super().test_save_load_local()





				@unittest.skip("""non-deterministic pipeline"""				)
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return super().test_inference_batch_single_identical()





				@skip_mps
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return super().test_dict_tuple_outputs_equivalent()





				@skip_mps
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return super().test_save_load_optional_components()





				@skip_mps
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return super().test_attention_slicing_forward_pass()






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






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()





				def      _lowerCAmelCase       ( self				):





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

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

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

							lowerCamelCase       =      """A black colored car"""
							lowerCamelCase       =      """A blue colored car"""

							lowerCamelCase       =      torch.manual_seed(0				)
							lowerCamelCase       =      pipe(
							    prompt=_a	,				source_prompt=_a	,				image=_a	,				num_inference_steps=100	,				eta=0.1	,				strength=0.85	,				guidance_scale=3	,				source_guidance_scale=1	,				generator=_a	,				output_type="""np"""	,				)
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





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

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

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

							lowerCamelCase       =      """A black colored car"""
							lowerCamelCase       =      """A blue colored car"""

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

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









"""simple docstring"""




def 					a__				(       snake_case__       )		->      list:
			if n_term == "":
						return []
			lowerCamelCase       =      []
			for temp in range(int(snake_case__       )       ):
						series.append(F'1/{temp + 1}' if series else """1"""       )
			return series


if __name__ == "__main__":
					lowerCAmelCase							:    Optional[int]  							=							input("""Enter the last number (nth term) of the Harmonic Series""")
					print("""Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n""")
					print(harmonic_series(nth_term))



