





import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()





class 			lowerCAmelCase__( __lowercase  ,     __lowercase  ,     __lowercase  ,     unittest.TestCase    ):






       '''simple docstring'''


       __snake_case 			=    StableUnCLIPPipeline
       __snake_case 			=    TEXT_TO_IMAGE_PARAMS
       __snake_case 			=    TEXT_TO_IMAGE_BATCH_PARAMS
       __snake_case 			=    TEXT_TO_IMAGE_IMAGE_PARAMS
       __snake_case 			=    TEXT_TO_IMAGE_IMAGE_PARAMS

       # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
       __snake_case 			=    False




       def     UpperCamelCase_			(      self							)			->     Dict:
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							3_2
            _SCREAMING_SNAKE_CASE       :	Any						    =							embedder_hidden_size

            # prior components

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	Dict						    =							CLIPTextModelWithProjection(
                CLIPTextConfig(
                    bos_token_id=0    ,						eos_token_id=2    ,						hidden_size=UpperCamelCase_    ,						projection_dim=UpperCamelCase_    ,						intermediate_size=3_7    ,						layer_norm_eps=1E-05    ,						num_attention_heads=4    ,						num_hidden_layers=5    ,						pad_token_id=1    ,						vocab_size=1_0_0_0    ,						)							)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	str						    =							PriorTransformer(
                num_attention_heads=2    ,						attention_head_dim=1_2    ,						embedding_dim=UpperCamelCase_    ,						num_layers=1    ,						)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							DDPMScheduler(
                variance_type="fixed_small_log"    ,						prediction_type="sample"    ,						num_train_timesteps=1_0_0_0    ,						clip_sample=UpperCamelCase_    ,						clip_sample_range=5.0    ,						beta_schedule="squaredcos_cap_v2"    ,						)

            # regular denoising components

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							DDPMScheduler(beta_schedule="squaredcos_cap_v2"							)

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

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							CLIPTextModel(
                CLIPTextConfig(
                    bos_token_id=0    ,						eos_token_id=2    ,						hidden_size=UpperCamelCase_    ,						projection_dim=3_2    ,						intermediate_size=3_7    ,						layer_norm_eps=1E-05    ,						num_attention_heads=4    ,						num_hidden_layers=5    ,						pad_token_id=1    ,						vocab_size=1_0_0_0    ,						)							)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	str						    =							UNetaDConditionModel(
                sample_size=3_2    ,						in_channels=4    ,						out_channels=4    ,						down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")    ,						up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")    ,						block_out_channels=(3_2, 6_4)    ,						attention_head_dim=(2, 4)    ,						class_embed_type="projection"    ,						projection_class_embeddings_input_dim=embedder_projection_dim * 2    ,						cross_attention_dim=UpperCamelCase_    ,						layers_per_block=1    ,						upcast_attention=UpperCamelCase_    ,						use_linear_projection=UpperCamelCase_    ,						)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	int						    =							DDIMScheduler(
                beta_schedule="scaled_linear"    ,						beta_start=0.0_0085    ,						beta_end=0.012    ,						prediction_type="v_prediction"    ,						set_alpha_to_one=UpperCamelCase_    ,						steps_offset=1    ,						)

            torch.manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							AutoencoderKL()

            _SCREAMING_SNAKE_CASE       :	int						    =							{
                # prior components
                "prior_tokenizer": prior_tokenizer,
                "prior_text_encoder": prior_text_encoder,
                "prior": prior,
                "prior_scheduler": prior_scheduler,
                # image noising components
                "image_normalizer": image_normalizer,
                "image_noising_scheduler": image_noising_scheduler,
                # regular denoising components
                "tokenizer": tokenizer,
                "text_encoder": text_encoder,
                "unet": unet,
                "scheduler": scheduler,
                "vae": vae,
            }

            return components




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase=0							)			->     Tuple:
            if str(UpperCamelCase_							).startswith("mps"							):
                 _SCREAMING_SNAKE_CASE       :	List[Any]						    =							torch.manual_seed(UpperCamelCase_							)
            else:
                 _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							torch.Generator(device=UpperCamelCase_							).manual_seed(UpperCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							{
                "prompt": "A painting of a squirrel eating a burger",
                "generator": generator,
                "num_inference_steps": 2,
                "prior_num_inference_steps": 2,
                "output_type": "numpy",
            }
            return inputs




       def     UpperCamelCase_			(      self							)			->     Tuple:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							torch_device == "cpu"

            self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase_							)







       def     UpperCamelCase_			(      self							)			->     List[Any]:
            _SCREAMING_SNAKE_CASE       :	str						    =							torch_device in ["cpu", "mps"]

            self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase_							)





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






       '''simple docstring'''


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




       def     UpperCamelCase_			(      self							)			->     Any:
            _SCREAMING_SNAKE_CASE       :	Any						    =							load_numpy(
                "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"							)

            _SCREAMING_SNAKE_CASE       :	List[str]						    =							StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"    ,						torch_dtype=torch.floataa							)
            pipe.to(UpperCamelCase_							)
            pipe.set_progress_bar_config(disable=UpperCamelCase_							)
            # 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()

            _SCREAMING_SNAKE_CASE       :	int						    =							torch.Generator(device="cpu"							).manual_seed(0							)
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							pipe("anime turle"    ,						generator=UpperCamelCase_    ,						output_type="np"							)

            _SCREAMING_SNAKE_CASE       :	Tuple						    =							output.images[0]

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

            assert_mean_pixel_difference(UpperCamelCase_    ,						UpperCamelCase_							)







       def     UpperCamelCase_			(      self							)			->     List[Any]:
            torch.cuda.empty_cache()
            torch.cuda.reset_max_memory_allocated()
            torch.cuda.reset_peak_memory_stats()

            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"    ,						torch_dtype=torch.floataa							)
            _SCREAMING_SNAKE_CASE       :	int						    =							pipe.to(UpperCamelCase_							)
            pipe.set_progress_bar_config(disable=UpperCamelCase_							)
            pipe.enable_attention_slicing()
            pipe.enable_sequential_cpu_offload()

            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							pipe(
                "anime turtle"    ,						prior_num_inference_steps=2    ,						num_inference_steps=2    ,						output_type="np"    ,						)

            _SCREAMING_SNAKE_CASE       :	Dict						    =							torch.cuda.max_memory_allocated()
            # make sure that less than 7 GB is allocated
            assert mem_bytes < 7 * 1_0**9









def     lowerCamelCase__			(__lowerCamelCase,       __lowerCamelCase	):
     if a < 0 or b < 0:
          raise ValueError("the value of both inputs must be positive"	)
     _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							str(bin(__lowerCamelCase	)	)[2:]  # remove the leading "0b"
     _SCREAMING_SNAKE_CASE       :	List[str]						    =							str(bin(__lowerCamelCase	)	)[2:]
     _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							max(len(__lowerCamelCase	),       len(__lowerCamelCase	)	)
     return "0b" + "".join(
         str(int("1" in (char_a, char_b)	)	)
         for char_a, char_b in zip(a_binary.zfill(__lowerCamelCase	),       b_binary.zfill(__lowerCamelCase	)	)	)


if __name__ == "__main__":
       import doctest

       doctest.testmod()