




'''simple docstring'''




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							):
       lowercase      :       Union[str, Any] 		=StableUnCLIPPipeline
       lowercase      :       List[str] 		=TEXT_TO_IMAGE_PARAMS
       lowercase      :       str 		=TEXT_TO_IMAGE_BATCH_PARAMS
       lowercase      :       Dict 		=TEXT_TO_IMAGE_IMAGE_PARAMS
       lowercase      :       List[str] 		=TEXT_TO_IMAGE_IMAGE_PARAMS

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






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=32
              lowerCamelCase_				=embedder_hidden_size

              # prior components

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

              torch.manual_seed(0    )
              lowerCamelCase_				=CLIPTextModelWithProjection(
                  CLIPTextConfig(
                      bos_token_id=0,						eos_token_id=2,						hidden_size=lowerCAmelCase,						projection_dim=lowerCAmelCase,						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    )
              lowerCamelCase_				=PriorTransformer(
                  num_attention_heads=2,						attention_head_dim=12,						embedding_dim=lowerCAmelCase,						num_layers=1,						)

              torch.manual_seed(0    )
              lowerCamelCase_				=DDPMScheduler(
                  variance_type='''fixed_small_log''',						prediction_type='''sample''',						num_train_timesteps=1_000,						clip_sample=lowerCAmelCase,						clip_sample_range=5.0,						beta_schedule='''squaredcos_cap_v2''',						)

              # regular denoising components

              torch.manual_seed(0    )
              lowerCamelCase_				=StableUnCLIPImageNormalizer(embedding_dim=lowerCAmelCase    )
              lowerCamelCase_				=DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''    )

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

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

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

              torch.manual_seed(0    )
              lowerCamelCase_				=AutoencoderKL()

              lowerCamelCase_				={
                  # 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,						lowerCAmelCase,						lowerCAmelCase=0    ):



              """simple docstring"""







              if str(lowerCAmelCase    ).startswith('''mps'''    ):
                     lowerCamelCase_				=torch.manual_seed(lowerCAmelCase    )
              else:
                     lowerCamelCase_				=torch.Generator(device=lowerCAmelCase    ).manual_seed(lowerCAmelCase    )
              lowerCamelCase_				={
                  '''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    ):



              """simple docstring"""







              lowerCamelCase_				=torch_device == '''cpu'''

              self._test_attention_slicing_forward_pass(test_max_difference=lowerCAmelCase    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=torch_device in ['''cpu''', '''mps''']

              self._test_inference_batch_single_identical(test_max_difference=lowerCAmelCase    )





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






       def 	lowercase__	(				self    ):



              """simple docstring"""







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






       def 	lowercase__	(				self    ):



              """simple docstring"""







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

              lowerCamelCase_				=output.images[0]

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

              assert_mean_pixel_difference(lowerCAmelCase,						lowerCAmelCase    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







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

              lowerCamelCase_				=StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''',						torch_dtype=torch.floataa    )
              lowerCamelCase_				=pipe.to(lowerCAmelCase    )
              pipe.set_progress_bar_config(disable=lowerCAmelCase    )
              pipe.enable_attention_slicing()
              pipe.enable_sequential_cpu_offload()

              lowerCamelCase_				=pipe(
                  '''anime turtle''',						prior_num_inference_steps=2,						num_inference_steps=2,						output_type='''np''',						)

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










'''simple docstring'''







from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)

@dataclass
class 	_snake_case(			UpperCAmelCase      ):
 __snake_case:							Union[List[PIL.Image.Image], np.ndarray]
 __snake_case:							Optional[List[bool]]
 __snake_case:							Optional[List[bool]]


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .pipeline_if import IFPipeline
    from .pipeline_if_imgaimg import IFImgaImgPipeline
    from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
    from .pipeline_if_inpainting import IFInpaintingPipeline
    from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
    from .pipeline_if_superresolution import IFSuperResolutionPipeline
    from .safety_checker import IFSafetyChecker
    from .watermark import IFWatermarker


