"""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 				snake_case       ( _snake_case      ,    _snake_case      ,    _snake_case      ,    unittest.TestCase				):




					"""simple docstring"""

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







					def 		__lowerCAmelCase						(				self   :	Union[str, Any]			):
									UpperCAmelCase__             =							32
									UpperCAmelCase__             =							embedder_hidden_size

									# image encoding components

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

									torch.manual_seed(0			)
									UpperCAmelCase__             =							CLIPVisionModelWithProjection(
									    CLIPVisionConfig(
									        hidden_size=__snake_case    ,projection_dim=__snake_case    ,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__             =							StableUnCLIPImageNormalizer(embedding_dim=__snake_case			)
									UpperCAmelCase__             =							DDPMScheduler(beta_schedule='squaredcos_cap_v2'			)

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

									torch.manual_seed(0			)
									UpperCAmelCase__             =							CLIPTextModel(
									    CLIPTextConfig(
									        bos_token_id=0    ,eos_token_id=2    ,hidden_size=__snake_case    ,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=1_000    ,)			)

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

									torch.manual_seed(0			)
									UpperCAmelCase__             =							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=__snake_case    ,steps_offset=1    ,)

									torch.manual_seed(0			)
									UpperCAmelCase__             =							AutoencoderKL()

									UpperCAmelCase__             =							{
									    # 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 		__lowerCAmelCase						(				self   :	Optional[Any]    ,lowerCamelCase__   :	Optional[Any]    ,lowerCamelCase__   :	List[Any]=0    ,lowerCamelCase__   :	Tuple=True			):
									if str(__snake_case			).startswith('mps'			):
													UpperCAmelCase__             =							torch.manual_seed(__snake_case			)
									else:
													UpperCAmelCase__             =							torch.Generator(device=__snake_case			).manual_seed(__snake_case			)

									UpperCAmelCase__             =							floats_tensor((1, 3, 32, 32)    ,rng=random.Random(__snake_case			)			).to(__snake_case			)

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

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







					@skip_mps
					def 		__lowerCAmelCase						(				self   :	Optional[int]			):
									UpperCAmelCase__             =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
									UpperCAmelCase__             =							self.get_dummy_components()
									UpperCAmelCase__             =							StableUnCLIPImgaImgPipeline(**__snake_case			)
									UpperCAmelCase__             =							sd_pipe.to(__snake_case			)
									sd_pipe.set_progress_bar_config(disable=__snake_case			)

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

									assert image.shape == (1, 32, 32, 3)
									UpperCAmelCase__             =							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 		__lowerCAmelCase						(				self   :	Union[str, Any]			):
									UpperCAmelCase__             =							torch_device in ["""cpu""", """mps"""]

									self._test_attention_slicing_forward_pass(test_max_difference=__snake_case			)







					def 		__lowerCAmelCase						(				self   :	Tuple			):
									UpperCAmelCase__             =							torch_device in ["""cpu""", """mps"""]

									self._test_inference_batch_single_identical(test_max_difference=__snake_case			)







					@unittest.skipIf(
					    torch_device != 'cuda' or not is_xformers_available()    ,reason='XFormers attention is only available with CUDA and `xformers` installed'    ,)
					def 		__lowerCAmelCase						(				self   :	List[Any]			):
									self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__snake_case			)






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




					"""simple docstring"""

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







					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							load_image(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'			)

									UpperCAmelCase__             =							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__             =							StableUnCLIPImgaImgPipeline.from_pretrained(
									    'fusing/stable-unclip-2-1-l-img2img'    ,torch_dtype=torch.floataa			)
									pipe.to(__snake_case			)
									pipe.set_progress_bar_config(disable=__snake_case			)
									# 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__             =							torch.Generator(device='cpu'			).manual_seed(0			)
									UpperCAmelCase__             =							pipe(__snake_case    ,'anime turle'    ,generator=__snake_case    ,output_type='np'			)

									UpperCAmelCase__             =							output.images[0]

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

									assert_mean_pixel_difference(__snake_case    ,__snake_case			)







					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							load_image(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'			)

									UpperCAmelCase__             =							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__             =							StableUnCLIPImgaImgPipeline.from_pretrained(
									    'fusing/stable-unclip-2-1-h-img2img'    ,torch_dtype=torch.floataa			)
									pipe.to(__snake_case			)
									pipe.set_progress_bar_config(disable=__snake_case			)
									# 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__             =							torch.Generator(device='cpu'			).manual_seed(0			)
									UpperCAmelCase__             =							pipe(__snake_case    ,'anime turle'    ,generator=__snake_case    ,output_type='np'			)

									UpperCAmelCase__             =							output.images[0]

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

									assert_mean_pixel_difference(__snake_case    ,__snake_case			)







					def 		__lowerCAmelCase						(				self   :	int			):
									UpperCAmelCase__             =							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__             =							StableUnCLIPImgaImgPipeline.from_pretrained(
									    'fusing/stable-unclip-2-1-h-img2img'    ,torch_dtype=torch.floataa			)
									UpperCAmelCase__             =							pipe.to(__snake_case			)
									pipe.set_progress_bar_config(disable=__snake_case			)
									pipe.enable_attention_slicing()
									pipe.enable_sequential_cpu_offload()

									UpperCAmelCase__             =							pipe(
									    __snake_case    ,'anime turtle'    ,num_inference_steps=2    ,output_type='np'    ,)

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







'''simple docstring'''


def 			snake_case_   (  SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       str     		=      0
				for ch in input_str:
								_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      ord(SCREAMING_SNAKE_CASE__     )
								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      pow(2							,      SCREAMING_SNAKE_CASE__     )

								# If we already turned on bit for current character's unicode
								if bitmap >> ch_unicode & 1 == 1:
												return False
								bitmap |= ch_bit_index_on
				return True


if __name__ == "__main__":
				import doctest

				doctest.testmod()




