
import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class     __UpperCamelCase (							__a ,						__a ,						unittest.TestCase       ):






     """simple docstring"""







     lowerCAmelCase_							   =			StableDiffusionXLImgaImgPipeline
     lowerCAmelCase_							   =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
     lowerCAmelCase_							   =			PipelineTesterMixin.required_optional_params - {'''latents'''}
     lowerCAmelCase_							   =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCAmelCase_							   =			IMAGE_TO_IMAGE_IMAGE_PARAMS
     lowerCAmelCase_							   =			IMAGE_TO_IMAGE_IMAGE_PARAMS



     def  UpperCAmelCase__							(				self							:							Optional[Any] ):







       """simple docstring"""




       torch.manual_seed(0 )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		UNetaDConditionModel(
           block_out_channels=(32, 64)     ,						layers_per_block=2     ,						sample_size=32     ,						in_channels=4     ,						out_channels=4     ,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,						attention_head_dim=(2, 4)     ,						use_linear_projection=lowercase_     ,						addition_embed_type='''text_time'''     ,						addition_time_embed_dim=8     ,						transformer_layers_per_block=(1, 2)     ,						projection_class_embeddings_input_dim=80     ,						cross_attention_dim=64     ,						)
       __SCREAMING_SNAKE_CASE      :	str					=		EulerDiscreteScheduler(
           beta_start=0.0_00_85     ,						beta_end=0.0_12     ,						steps_offset=1     ,						beta_schedule='''scaled_linear'''     ,						timestep_spacing='''leading'''     ,						)
       torch.manual_seed(0 )
       __SCREAMING_SNAKE_CASE      :	Dict					=		AutoencoderKL(
           block_out_channels=[32, 64]     ,						in_channels=3     ,						out_channels=3     ,						down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,						up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,						latent_channels=4     ,						sample_size=128     ,						)
       torch.manual_seed(0 )
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		CLIPTextConfig(
           bos_token_id=0     ,						eos_token_id=2     ,						hidden_size=32     ,						intermediate_size=37     ,						layer_norm_eps=1e-05     ,						num_attention_heads=4     ,						num_hidden_layers=5     ,						pad_token_id=1     ,						vocab_size=1000     ,						hidden_act='''gelu'''     ,						projection_dim=32     ,						)
       __SCREAMING_SNAKE_CASE      :	str					=		CLIPTextModel(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Tuple					=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     ,						local_files_only=lowercase_ )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		CLIPTextModelWithProjection(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	str					=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     ,						local_files_only=lowercase_ )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		{
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''text_encoder_2''': text_encoder_a,
           '''tokenizer_2''': tokenizer_a,
           # "safety_checker": None,
           # "feature_extractor": None,
       }
       return components



     def  UpperCAmelCase__							(				self							:							List[Any]     ,						_A							:							List[Any]     ,						_A							:							Union[str, Any]=0 ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		floats_tensor((1, 3, 32, 32)     ,						rng=random.Random(lowercase_ ) ).to(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		image / 2 + 0.5
       if str(lowercase_ ).startswith('''mps''' ):
         __SCREAMING_SNAKE_CASE      :	str					=		torch.manual_seed(lowercase_ )
       else:
         __SCREAMING_SNAKE_CASE      :	Tuple					=		torch.Generator(device=lowercase_ ).manual_seed(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		{
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''image''': image,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 5.0,
           '''output_type''': '''numpy''',
           '''strength''': 0.75,
       }
       return inputs



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Any					=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       __SCREAMING_SNAKE_CASE      :	str					=		self.get_dummy_components()
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		StableDiffusionXLImgaImgPipeline(**lowercase_ )
       __SCREAMING_SNAKE_CASE      :	int					=		sd_pipe.to(lowercase_ )
       sd_pipe.set_progress_bar_config(disable=lowercase_ )

       __SCREAMING_SNAKE_CASE      :	Any					=		self.get_dummy_inputs(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	str					=		sd_pipe(**lowercase_ ).images
       __SCREAMING_SNAKE_CASE      :	Dict					=		image[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)

       __SCREAMING_SNAKE_CASE      :	List[str]					=		np.array([0.46_56, 0.48_40, 0.44_39, 0.66_98, 0.55_74, 0.45_24, 0.57_99, 0.59_43, 0.51_65] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2



     def  UpperCAmelCase__							(				self							:							Optional[Any] ):







       """simple docstring"""




       super().test_attention_slicing_forward_pass(expected_max_diff=3e-3 )



     def  UpperCAmelCase__							(				self							:							List[Any] ):







       """simple docstring"""




       super().test_inference_batch_single_identical(expected_max_diff=3e-3 )



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       pass




     def  UpperCAmelCase__							(				self							:							Dict ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		self.get_dummy_components()
       __SCREAMING_SNAKE_CASE      :	Dict					=		StableDiffusionXLImgaImgPipeline(**lowercase_ )
       __SCREAMING_SNAKE_CASE      :	str					=		sd_pipe.to(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	int					=		sd_pipe.to(lowercase_ )
       sd_pipe.set_progress_bar_config(disable=lowercase_ )

       # forward without prompt embeds
       __SCREAMING_SNAKE_CASE      :	Dict					=		self.get_dummy_inputs(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Any					=		3 * ['''this is a negative prompt''']
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		negative_prompt
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		3 * [inputs['''prompt''']]

       __SCREAMING_SNAKE_CASE      :	int					=		sd_pipe(**lowercase_ )
       __SCREAMING_SNAKE_CASE      :	str					=		output.images[0, -3:, -3:, -1]

       # forward with prompt embeds
       __SCREAMING_SNAKE_CASE      :	Any					=		self.get_dummy_inputs(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		3 * ['''this is a negative prompt''']
       __SCREAMING_SNAKE_CASE      :	Any					=		3 * [inputs.pop('''prompt''' )]

       (
           (
           __SCREAMING_SNAKE_CASE	
       ),		(
           __SCREAMING_SNAKE_CASE	
       ),		(
           __SCREAMING_SNAKE_CASE	
       ),		(
           __SCREAMING_SNAKE_CASE	
       ),			
       )      :	List[str]					=		sd_pipe.encode_prompt(lowercase_     ,						negative_prompt=lowercase_ )

       __SCREAMING_SNAKE_CASE      :	Any					=		sd_pipe(
           **lowercase_     ,						prompt_embeds=lowercase_     ,						negative_prompt_embeds=lowercase_     ,						pooled_prompt_embeds=lowercase_     ,						negative_pooled_prompt_embeds=lowercase_     ,						)
       __SCREAMING_SNAKE_CASE      :	str					=		output.images[0, -3:, -3:, -1]

       # make sure that it's equal
       assert np.abs(image_slice_a.flatten() - image_slice_a.flatten() ).max() < 1e-4






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






     """simple docstring"""







     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




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



     def  UpperCAmelCase__							(				self							:							Dict     ,						_A							:							Tuple     ,						_A							:							Dict="cpu"     ,						_A							:							Union[str, Any]=torch.floataa     ,						_A							:							int=0 ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Any					=		torch.Generator(device=lowercase_ ).manual_seed(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		np.random.RandomState(lowercase_ ).standard_normal((1, 4, 64, 64) )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		torch.from_numpy(lowercase_ ).to(device=lowercase_     ,						dtype=lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		{
           '''prompt''': '''a photograph of an astronaut riding a horse''',
           '''latents''': latents,
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs




     def  UpperCAmelCase__							(				self							:							Union[str, Any] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	str					=		DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base''' )
       pipe.to(lowercase_ )
       pipe.set_progress_bar_config(disable=lowercase_ )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		self.get_inputs(lowercase_ )
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		pipe(**lowercase_ ).images
       __SCREAMING_SNAKE_CASE      :	Any					=		image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 512, 3)
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		np.array([0.4_94_93, 0.4_78_96, 0.4_07_98, 0.5_42_14, 0.5_32_12, 0.4_82_02, 0.4_76_56, 0.4_63_29, 0.4_85_06] )
       assert np.abs(image_slice - expected_slice ).max() < 7e-3

'''simple docstring'''


import warnings

from ...utils import logging
from .image_processing_poolformer import PoolFormerImageProcessor


__snake_case						  =		logging.get_logger(__name__)





class       _a    (		__a      ):


  """simple docstring"""

  def __init__(		self      :       int   ,				*lowercase_      :       Tuple   ,				**lowercase_      :       List[Any]      ):







    '''simple docstring'''


    warnings.warn(
        """The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
        """ Please use PoolFormerImageProcessor instead."""   ,				lowercase_   ,				)
    super().__init__(*lowercase_   ,				**lowercase_      )

