

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  lowercase				(       lowercase_	,  lowercase_	,  lowercase_	,  unittest.TestCase			):
				__SCREAMING_SNAKE_CASE					: Tuple       			=			StableUnCLIPPipeline
				__SCREAMING_SNAKE_CASE					: Optional[int]       			=			TEXT_TO_IMAGE_PARAMS
				__SCREAMING_SNAKE_CASE					: str       			=			TEXT_TO_IMAGE_BATCH_PARAMS
				__SCREAMING_SNAKE_CASE					: int       			=			TEXT_TO_IMAGE_IMAGE_PARAMS
				__SCREAMING_SNAKE_CASE					: Tuple       			=			TEXT_TO_IMAGE_IMAGE_PARAMS

				# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
				__SCREAMING_SNAKE_CASE					: Union[str, Any]       			=			False




				def     a							(					self       ):
											snake_case_							=    32
											snake_case_							=    embedder_hidden_size

											# prior components

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

											torch.manual_seed(0       )
											snake_case_							=    CLIPTextModelWithProjection(
											    CLIPTextConfig(
											        bos_token_id=0      ,   eos_token_id=2      ,   hidden_size=__A      ,   projection_dim=__A      ,   intermediate_size=37      ,   layer_norm_eps=1e-0_5      ,   num_attention_heads=4      ,   num_hidden_layers=5      ,   pad_token_id=1      ,   vocab_size=1000      ,   )       )

											torch.manual_seed(0       )
											snake_case_							=    PriorTransformer(
											    num_attention_heads=2      ,   attention_head_dim=12      ,   embedding_dim=__A      ,   num_layers=1      ,   )

											torch.manual_seed(0       )
											snake_case_							=    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       )
											snake_case_							=    StableUnCLIPImageNormalizer(embedding_dim=__A       )
											snake_case_							=    DDPMScheduler(beta_schedule='squaredcos_cap_v2'       )

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

											torch.manual_seed(0       )
											snake_case_							=    CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0      ,   eos_token_id=2      ,   hidden_size=__A      ,   projection_dim=32      ,   intermediate_size=37      ,   layer_norm_eps=1e-0_5      ,   num_attention_heads=4      ,   num_hidden_layers=5      ,   pad_token_id=1      ,   vocab_size=1000      ,   )       )

											torch.manual_seed(0       )
											snake_case_							=    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       )
											snake_case_							=    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       )
											snake_case_							=    AutoencoderKL()

											snake_case_							=    {
											    # 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     a							(					self      ,   snake_case      ,   snake_case=0       ):





											if str(__A       ).startswith('mps'       ):
																		snake_case_							=    torch.manual_seed(__A       )
											else:
																		snake_case_							=    torch.Generator(device=__A       ).manual_seed(__A       )
											snake_case_							=    {
											    "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     a							(					self       ):
											snake_case_							=    torch_device == "cpu"

											self._test_attention_slicing_forward_pass(test_max_difference=__A       )




				def     a							(					self       ):
											snake_case_							=    torch_device in ["cpu", "mps"]

											self._test_inference_batch_single_identical(test_max_difference=__A       )







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




				def     a							(					self       ):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




				def     a							(					self       ):
											snake_case_							=    load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'       )

											snake_case_							=    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()

											snake_case_							=    torch.Generator(device='cpu'       ).manual_seed(0       )
											snake_case_							=    pipe('anime turle'      ,   generator=__A      ,   output_type='np'       )

											snake_case_							=    output.images[0]

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

											assert_mean_pixel_difference(__A      ,   __A       )




				def     a							(					self       ):
											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

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

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

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








from ..utils import DummyObject, requires_backends
class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Any     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Optional[int]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      str     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      List[Any]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Optional[int]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Dict     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Dict     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Union[str, Any]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Optional[int]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Optional[Any]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Any     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      Optional[Any]     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



class 	UpperCAmelCase_					(					metaclass=UpperCamelCase    ):

   '''simple docstring'''




   __A :      int     		=		["flax"]






   def __init__(		self						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(self						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )






   @classmethod
   def _snake_case    (		cls						,				*__A						,				**__A ):






     """simple docstring"""





     requires_backends(cls						,				["flax"] )



