





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       A__     ( __snake_case ,     __snake_case ,     __snake_case ,     unittest.TestCase    ):
      _UpperCAmelCase			:Dict							=     StableUnCLIPPipeline
      _UpperCAmelCase			:List[str]							=     TEXT_TO_IMAGE_PARAMS
      _UpperCAmelCase			:Tuple							=     TEXT_TO_IMAGE_BATCH_PARAMS
      _UpperCAmelCase			:Optional[Any]							=     TEXT_TO_IMAGE_IMAGE_PARAMS
      _UpperCAmelCase			:List[Any]							=     TEXT_TO_IMAGE_IMAGE_PARAMS

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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[Any] 			=     32
       UpperCamelCase			:      Union[str, Any] 			=     embedder_hidden_size

       # prior components

       torch.manual_seed(0     )
       UpperCamelCase			:      Tuple 			=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

       torch.manual_seed(0     )
       UpperCamelCase			:      Any 			=     CLIPTextModelWithProjection(
           CLIPTextConfig(
               bos_token_id=0 ,							eos_token_id=2 ,							hidden_size=A_ ,							projection_dim=A_ ,							intermediate_size=37 ,							layer_norm_eps=1e-05 ,							num_attention_heads=4 ,							num_hidden_layers=5 ,							pad_token_id=1 ,							vocab_size=1000 ,							)     )

       torch.manual_seed(0     )
       UpperCamelCase			:      Optional[int] 			=     PriorTransformer(
           num_attention_heads=2 ,							attention_head_dim=12 ,							embedding_dim=A_ ,							num_layers=1 ,							)

       torch.manual_seed(0     )
       UpperCamelCase			:      Optional[Any] 			=     DDPMScheduler(
           variance_type="fixed_small_log" ,							prediction_type="sample" ,							num_train_timesteps=1000 ,							clip_sample=A_ ,							clip_sample_range=5.0 ,							beta_schedule="squaredcos_cap_v2" ,							)

       # regular denoising components

       torch.manual_seed(0     )
       UpperCamelCase			:      Tuple 			=     StableUnCLIPImageNormalizer(embedding_dim=A_     )
       UpperCamelCase			:      Optional[int] 			=     DDPMScheduler(beta_schedule="squaredcos_cap_v2"     )

       torch.manual_seed(0     )
       UpperCamelCase			:      str 			=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

       torch.manual_seed(0     )
       UpperCamelCase			:      Dict 			=     CLIPTextModel(
           CLIPTextConfig(
               bos_token_id=0 ,							eos_token_id=2 ,							hidden_size=A_ ,							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=1000 ,							)     )

       torch.manual_seed(0     )
       UpperCamelCase			:      Optional[Any] 			=     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=A_ ,							layers_per_block=1 ,							upcast_attention=A_ ,							use_linear_projection=A_ ,							)

       torch.manual_seed(0     )
       UpperCamelCase			:      Union[str, Any] 			=     DDIMScheduler(
           beta_schedule="scaled_linear" ,							beta_start=0.0_00_85 ,							beta_end=0.0_12 ,							prediction_type="v_prediction" ,							set_alpha_to_one=A_ ,							steps_offset=1 ,							)

       torch.manual_seed(0     )
       UpperCamelCase			:      Any 			=     AutoencoderKL()

       UpperCamelCase			:      List[Any] 			=     {
           # 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 ,							A_ ,							A_=0     ):
       '''simple docstring'''




       if str(A_     ).startswith("mps"     ):
        UpperCamelCase			:      List[str] 			=     torch.manual_seed(A_     )
       else:
        UpperCamelCase			:      str 			=     torch.Generator(device=A_     ).manual_seed(A_     )
       UpperCamelCase			:      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     ):
       '''simple docstring'''




       UpperCamelCase			:      Any 			=     torch_device == "cpu"

       self._test_attention_slicing_forward_pass(test_max_difference=A_     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      List[str] 			=     torch_device in ["cpu", "mps"]

       self._test_inference_batch_single_identical(test_max_difference=A_     )



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





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Optional[int] 			=     load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"     )

       UpperCamelCase			:      Union[str, Any] 			=     StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l" ,							torch_dtype=torch.floataa     )
       pipe.to(A_     )
       pipe.set_progress_bar_config(disable=A_     )
       # 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[int] 			=     torch.Generator(device="cpu"     ).manual_seed(0     )
       UpperCamelCase			:      Tuple 			=     pipe("anime turle" ,							generator=A_ ,							output_type="np"     )

       UpperCamelCase			:      str 			=     output.images[0]

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

       assert_mean_pixel_difference(A_ ,							A_     )





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

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

       UpperCamelCase			:      List[Any] 			=     pipe(
           "anime turtle" ,							prior_num_inference_steps=2 ,							num_inference_steps=2 ,							output_type="np" ,							)

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







def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				int:
 return int(input_a == input_a == 0  )



def 	A_       (  )		->				None:
 print("Truth Table of NOR Gate:"  )
 print("|   Input 1   |  Input 2  | Output |"  )
 print(F"""|      0      |    0      |  {nor_gate(0							,     0  )}     |"""  )
 print(F"""|      0      |    1      |  {nor_gate(0							,     1  )}     |"""  )
 print(F"""|      1      |    0      |  {nor_gate(1							,     0  )}     |"""  )
 print(F"""|      1      |    1      |  {nor_gate(1							,     1  )}     |"""  )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()
