




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 		UpperCamelCase__	(lowerCAmelCase__    ,				lowerCAmelCase__    ,				lowerCAmelCase__    ,				unittest.TestCase     ):

    '''simple docstring'''



    lowerCamelCase_      :	List[Any]	     =      StableUnCLIPPipeline
    lowerCamelCase_      :	List[Any]	     =      TEXT_TO_IMAGE_PARAMS
    lowerCamelCase_      :	Dict	     =      TEXT_TO_IMAGE_BATCH_PARAMS
    lowerCamelCase_      :	List[Any]	     =      TEXT_TO_IMAGE_IMAGE_PARAMS
    lowerCamelCase_      :	int	     =      TEXT_TO_IMAGE_IMAGE_PARAMS

    # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
    lowerCamelCase_      :	Optional[int]	     =      False







    def     _lowercase     (    self     )     ->      str:
           lowerCamelCase   :      List[Any]			 =					32
           lowerCamelCase   :      str			 =					embedder_hidden_size

           # prior components

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

           torch.manual_seed(0     )
           lowerCamelCase   :      Union[str, Any]			 =					CLIPTextModelWithProjection(
               CLIPTextConfig(
                   bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=UpperCamelCase__     ,  projection_dim=UpperCamelCase__     ,  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     )
           lowerCamelCase   :      Union[str, Any]			 =					PriorTransformer(
               num_attention_heads=2     ,  attention_head_dim=12     ,  embedding_dim=UpperCamelCase__     ,  num_layers=1     ,  )

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

           # regular denoising components

           torch.manual_seed(0     )
           lowerCamelCase   :      str			 =					StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase__     )
           lowerCamelCase   :      List[str]			 =					DDPMScheduler(beta_schedule="squaredcos_cap_v2"     )

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

           torch.manual_seed(0     )
           lowerCamelCase   :      Tuple			 =					CLIPTextModel(
               CLIPTextConfig(
                   bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=UpperCamelCase__     ,  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     )
           lowerCamelCase   :      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=UpperCamelCase__     ,  layers_per_block=1     ,  upcast_attention=UpperCamelCase__     ,  use_linear_projection=UpperCamelCase__     ,  )

           torch.manual_seed(0     )
           lowerCamelCase   :      List[Any]			 =					DDIMScheduler(
               beta_schedule="scaled_linear"     ,  beta_start=0.00085     ,  beta_end=0.012     ,  prediction_type="v_prediction"     ,  set_alpha_to_one=UpperCamelCase__     ,  steps_offset=1     ,  )

           torch.manual_seed(0     )
           lowerCamelCase   :      List[str]			 =					AutoencoderKL()

           lowerCamelCase   :      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     _lowercase     (    self     ,  UpperCamelCase__     ,  UpperCamelCase__=0     )     ->      str:
           if str(UpperCamelCase__     ).startswith("mps"     ):
                  lowerCamelCase   :      Optional[int]			 =					torch.manual_seed(UpperCamelCase__     )
           else:
                  lowerCamelCase   :      str			 =					torch.Generator(device=UpperCamelCase__     ).manual_seed(UpperCamelCase__     )
           lowerCamelCase   :      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     _lowercase     (    self     )     ->      int:
           lowerCamelCase   :      List[str]			 =					torch_device == "cpu"

           self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase__     )







    def     _lowercase     (    self     )     ->      Optional[Any]:
           lowerCamelCase   :      str			 =					torch_device in ["cpu", "mps"]

           self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase__     )




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

    '''simple docstring'''



    def     _lowercase     (    self     )     ->      Dict:
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()







    def     _lowercase     (    self     )     ->      str:
           lowerCamelCase   :      List[str]			 =					load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"     )

           lowerCamelCase   :      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()

           lowerCamelCase   :      Optional[int]			 =					torch.Generator(device="cpu"     ).manual_seed(0     )
           lowerCamelCase   :      Optional[int]			 =					pipe("anime turle"     ,  generator=UpperCamelCase__     ,  output_type="np"     )

           lowerCamelCase   :      int			 =					output.images[0]

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

           assert_mean_pixel_difference(UpperCamelCase__     ,  UpperCamelCase__     )







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

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

           lowerCamelCase   :      Tuple			 =					pipe(
               "anime turtle"     ,  prior_num_inference_steps=2     ,  num_inference_steps=2     ,  output_type="np"     ,  )

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












def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> int:
       return x if y == 0 else greatest_common_divisor(_SCREAMING_SNAKE_CASE ,x % y    )

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> int:
       return (x * y) // greatest_common_divisor(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )

def      A      (      _SCREAMING_SNAKE_CASE = 20    )	-> int:
       lowerCamelCase   :      List[Any]			 =					1
       for i in range(1 ,n + 1    ):
              lowerCamelCase   :      List[str]			 =					lcm(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
       return g


if __name__ == "__main__":
       print(f'''{solution() = }''')






