





'''simple docstring'''







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 					__a      (lowerCamelCase       ,		lowerCamelCase       ,		lowerCamelCase       ,		unittest.TestCase     ):
							__a					:   Optional[Any]									=       StableUnCLIPImgaImgPipeline
							__a					:   str									=       TEXT_GUIDED_IMAGE_VARIATION_PARAMS
							__a					:   int									=       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							__a					:   List[str]									=       frozenset(
							    []     )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							__a					:   str									=       frozenset([]     )

							def     UpperCAmelCase__	(							self							:     str   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  32
													UpperCAmelCase_			:      Optional[int]     						=  embedder_hidden_size

													# image encoding components

													UpperCAmelCase_			:      Tuple     						=  CLIPImageProcessor(crop_size=32       ,     size=32   )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Any     						=  CLIPVisionModelWithProjection(
													    CLIPVisionConfig(
													        hidden_size=__magic_name__       ,     projection_dim=__magic_name__       ,     num_hidden_layers=5       ,     num_attention_heads=4       ,     image_size=32       ,     intermediate_size=37       ,     patch_size=1       ,     )   )

													# regular denoising components

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Any     						=  StableUnCLIPImageNormalizer(embedding_dim=__magic_name__   )
													UpperCAmelCase_			:      List[str]     						=  DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''   )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Optional[int]     						=  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Optional[Any]     						=  CLIPTextModel(
													    CLIPTextConfig(
													        bos_token_id=0       ,     eos_token_id=2       ,     hidden_size=__magic_name__       ,     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=10_00       ,     )   )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      List[str]     						=  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=__magic_name__       ,     layers_per_block=1       ,     upcast_attention=__magic_name__       ,     use_linear_projection=__magic_name__       ,     )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Tuple     						=  DDIMScheduler(
													    beta_schedule='''scaled_linear'''       ,     beta_start=0.0_0_0_8_5       ,     beta_end=0.0_1_2       ,     prediction_type='''v_prediction'''       ,     set_alpha_to_one=__magic_name__       ,     steps_offset=1       ,     )

													torch.manual_seed(0   )
													UpperCAmelCase_			:      Union[str, Any]     						=  AutoencoderKL()

													UpperCAmelCase_			:      Any     						=  {
													    # 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       ,     __magic_name__							:     str       ,     __magic_name__							:     Any=0       ,     __magic_name__							:     List[str]=True   )					->       List[Any]:







													"""simple docstring"""
													if str(__magic_name__   ).startswith('''mps'''   ):
																			UpperCAmelCase_			:      str     						=  torch.manual_seed(__magic_name__   )
													else:
																			UpperCAmelCase_			:      Union[str, Any]     						=  torch.Generator(device=__magic_name__   ).manual_seed(__magic_name__   )

													UpperCAmelCase_			:      List[Any]     						=  floats_tensor((1, 3, 32, 32)       ,     rng=random.Random(__magic_name__   )   ).to(__magic_name__   )

													if pil_image:
																			UpperCAmelCase_			:      Any     						=  input_image * 0.5 + 0.5
																			UpperCAmelCase_			:      List[str]     						=  input_image.clamp(0       ,     1   )
																			UpperCAmelCase_			:      Union[str, Any]     						=  input_image.cpu().permute(0       ,     2       ,     3       ,     1   ).float().numpy()
																			UpperCAmelCase_			:      Tuple     						=  DiffusionPipeline.numpy_to_pil(__magic_name__   )[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							:     Union[str, Any]   )					->       Tuple:







													"""simple docstring"""
													UpperCAmelCase_			:      int     						=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
													UpperCAmelCase_			:      List[Any]     						=  self.get_dummy_components()
													UpperCAmelCase_			:      Tuple     						=  StableUnCLIPImgaImgPipeline(**__magic_name__   )
													UpperCAmelCase_			:      Tuple     						=  sd_pipe.to(__magic_name__   )
													sd_pipe.set_progress_bar_config(disable=__magic_name__   )

													UpperCAmelCase_			:      Optional[Any]     						=  self.get_dummy_inputs(__magic_name__   )
													inputs.update({'''image_embeds''': None}   )
													UpperCAmelCase_			:      Tuple     						=  sd_pipe(**__magic_name__   ).images
													UpperCAmelCase_			:      int     						=  image[0, -3:, -3:, -1]

													assert image.shape == (1, 32, 32, 3)
													UpperCAmelCase_			:      Any     						=  np.array([0.3_8_7_2, 0.7_2_2_4, 0.5_6_0_1, 0.4_7_4_1, 0.6_8_7_2, 0.5_8_1_4, 0.4_6_3_6, 0.3_8_6_7, 0.5_0_7_8]   )

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

							def     UpperCAmelCase__	(							self							:     Tuple   )					->       Any:







													"""simple docstring"""
													UpperCAmelCase_			:      Dict     						=  torch_device in ['''cpu''', '''mps''']

													self._test_attention_slicing_forward_pass(test_max_difference=__magic_name__   )

							def     UpperCAmelCase__	(							self							:     List[Any]   )					->       Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  torch_device in ['''cpu''', '''mps''']

													self._test_inference_batch_single_identical(test_max_difference=__magic_name__   )



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







													"""simple docstring"""
													self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__magic_name__   )





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

							def     UpperCAmelCase__	(							self							:     Any   )					->       Dict:







													"""simple docstring"""
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()

							def     UpperCAmelCase__	(							self							:     Optional[int]   )					->       int:







													"""simple docstring"""
													UpperCAmelCase_			:      Any     						=  load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'''   )

													UpperCAmelCase_			:      str     						=  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'''   )

													UpperCAmelCase_			:      List[str]     						=  StableUnCLIPImgaImgPipeline.from_pretrained(
													    '''fusing/stable-unclip-2-1-l-img2img'''       ,     torch_dtype=torch.floataa   )
													pipe.to(__magic_name__   )
													pipe.set_progress_bar_config(disable=__magic_name__   )
													# 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()

													UpperCAmelCase_			:      int     						=  torch.Generator(device='''cpu'''   ).manual_seed(0   )
													UpperCAmelCase_			:      Tuple     						=  pipe(__magic_name__       ,     '''anime turle'''       ,     generator=__magic_name__       ,     output_type='''np'''   )

													UpperCAmelCase_			:      List[Any]     						=  output.images[0]

													assert image.shape == (7_68, 7_68, 3)

													assert_mean_pixel_difference(__magic_name__       ,     __magic_name__   )

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







													"""simple docstring"""
													UpperCAmelCase_			:      Tuple     						=  load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'''   )

													UpperCAmelCase_			:      Optional[int]     						=  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'''   )

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

													UpperCAmelCase_			:      Optional[Any]     						=  torch.Generator(device='''cpu'''   ).manual_seed(0   )
													UpperCAmelCase_			:      List[Any]     						=  pipe(__magic_name__       ,     '''anime turle'''       ,     generator=__magic_name__       ,     output_type='''np'''   )

													UpperCAmelCase_			:      Dict     						=  output.images[0]

													assert image.shape == (7_68, 7_68, 3)

													assert_mean_pixel_difference(__magic_name__       ,     __magic_name__   )



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







													"""simple docstring"""
													UpperCAmelCase_			:      Tuple     						=  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()

													UpperCAmelCase_			:      Dict     						=  StableUnCLIPImgaImgPipeline.from_pretrained(
													    '''fusing/stable-unclip-2-1-h-img2img'''       ,     torch_dtype=torch.floataa   )
													UpperCAmelCase_			:      Tuple     						=  pipe.to(__magic_name__   )
													pipe.set_progress_bar_config(disable=__magic_name__   )
													pipe.enable_attention_slicing()
													pipe.enable_sequential_cpu_offload()

													UpperCAmelCase_			:      Dict     						=  pipe(
													    __magic_name__       ,     '''anime turtle'''       ,     num_inference_steps=2       ,     output_type='''np'''       ,     )

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












'''simple docstring'''







def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int,			SCREAMING_SNAKE_CASE__      :			int   ) ->	int:
						return abs(SCREAMING_SNAKE_CASE__   ) if a == 0 else greatest_common_divisor(b % a,			SCREAMING_SNAKE_CASE__   )





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int,			SCREAMING_SNAKE_CASE__      :			int   ) ->	int:
						while y:  # --> when y=0 then loop will terminate and return x as final GCD.
												UpperCAmelCase_						,       UpperCAmelCase_			:      Optional[Any]     						=  y, x % y
						return abs(SCREAMING_SNAKE_CASE__   )





def        lowerCamelCase_      (  ) ->	Optional[int]:
						try:
												UpperCAmelCase_			:      Optional[Any]     						=  input('''Enter two integers separated by comma (,): '''   ).split(''','''   )
												UpperCAmelCase_			:      Optional[int]     						=  int(nums[0]   )
												UpperCAmelCase_			:      List[Any]     						=  int(nums[1]   )
												print(
												    F"""greatest_common_divisor({num_a}, {num_a}) = """
												    F"""{greatest_common_divisor(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )}"""   )
												print(F"""By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )}"""   )
						except (IndexError, UnboundLocalError, ValueError):
												print('''Wrong input'''   )


if __name__ == "__main__":
					main()





