import gc
import unittest

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

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

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class     __UpperCAmelCase(    lowerCAmelCase_      ,	lowerCAmelCase_      ,	unittest.TestCase				):






 """simple docstring"""




 __magic_name__          =   StableDiffusionXLPipeline
 __magic_name__          =   TEXT_TO_IMAGE_PARAMS
 __magic_name__          =   TEXT_TO_IMAGE_BATCH_PARAMS
 __magic_name__          =   TEXT_TO_IMAGE_IMAGE_PARAMS
 __magic_name__          =   TEXT_TO_IMAGE_IMAGE_PARAMS
 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

        torch.manual_seed(0      )
        A_							:       Optional[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=_SCREAMING_SNAKE_CASE ,       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 ,       )
        A_							:       Dict	      =				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      )
        A_							:       Optional[int]	      =				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      )
        A_							:       int	      =				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 ,       )
        A_							:       List[Any]	      =				CLIPTextModel(_SCREAMING_SNAKE_CASE      )
        A_							:       Any	      =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ,       local_files_only=_SCREAMING_SNAKE_CASE      )

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

        A_							:       int	      =				{
            '''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 ,       __magic_name__ ,       __magic_name__=0      ):

        """simple docstring"""

        if str(_SCREAMING_SNAKE_CASE      ).startswith('''mps'''      ):
               A_							:       str	      =				torch.manual_seed(_SCREAMING_SNAKE_CASE      )
        else:
               A_							:       Optional[int]	      =				torch.Generator(device=_SCREAMING_SNAKE_CASE      ).manual_seed(_SCREAMING_SNAKE_CASE      )
        A_							:       Dict	      =				{
            '''prompt''': '''A painting of a squirrel eating a burger''',
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 5.0,
            '''output_type''': '''numpy''',
        }
        return inputs
 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

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

        A_							:       Optional[int]	      =				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE      )
        A_							:       List[Any]	      =				sd_pipe(**_SCREAMING_SNAKE_CASE      ).images
        A_							:       int	      =				image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        A_							:       str	      =				np.array([0.58_73, 0.61_28, 0.47_97, 0.51_22, 0.56_74, 0.46_39, 0.52_27, 0.51_49, 0.47_47]      )

        assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

        A_							:       Any	      =				self.get_dummy_components()
        A_							:       int	      =				StableDiffusionXLPipeline(**_SCREAMING_SNAKE_CASE      )
        A_							:       Any	      =				sd_pipe.to(_SCREAMING_SNAKE_CASE      )
        A_							:       List[str]	      =				sd_pipe.to(_SCREAMING_SNAKE_CASE      )
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE      )

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

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

        # forward with prompt embeds
        A_							:       Union[str, Any]	      =				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE      )
        A_							:       Union[str, Any]	      =				3 * ['''this is a negative prompt''']
        A_							:       str	      =				3 * [inputs.pop('''prompt'''      )]

        (
            (
            A_			
        )      ,							(
            A_			
        )      ,							(
            A_			
        )      ,							(
            A_			
        )      ,										
        )							:       Dict	      =				sd_pipe.encode_prompt(_SCREAMING_SNAKE_CASE ,       negative_prompt=_SCREAMING_SNAKE_CASE      )

        A_							:       Any	      =				sd_pipe(
            **_SCREAMING_SNAKE_CASE ,       prompt_embeds=_SCREAMING_SNAKE_CASE ,       negative_prompt_embeds=_SCREAMING_SNAKE_CASE ,       pooled_prompt_embeds=_SCREAMING_SNAKE_CASE ,       negative_pooled_prompt_embeds=_SCREAMING_SNAKE_CASE ,       )
        A_							:       Optional[int]	      =				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
 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

        super().test_attention_slicing_forward_pass(expected_max_diff=3e-3      )
 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

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






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






 """simple docstring"""




 def  UpperCAmelCase   (    self      ):

        """simple docstring"""

        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()
 def  UpperCAmelCase   (    self ,       __magic_name__ ,       __magic_name__="cpu" ,       __magic_name__=torch.floataa ,       __magic_name__=0      ):

        """simple docstring"""

        A_							:       Any	      =				torch.Generator(device=_SCREAMING_SNAKE_CASE      ).manual_seed(_SCREAMING_SNAKE_CASE      )
        A_							:       Dict	      =				np.random.RandomState(_SCREAMING_SNAKE_CASE      ).standard_normal((1, 4, 64, 64)      )
        A_							:       List[str]	      =				torch.from_numpy(_SCREAMING_SNAKE_CASE      ).to(device=_SCREAMING_SNAKE_CASE ,       dtype=_SCREAMING_SNAKE_CASE      )
        A_							:       Tuple	      =				{
            '''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      ):

        """simple docstring"""

        A_							:       Any	      =				DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''      )
        pipe.to(_SCREAMING_SNAKE_CASE      )
        pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE      )

        A_							:       List[Any]	      =				self.get_inputs(_SCREAMING_SNAKE_CASE      )
        A_							:       Optional[int]	      =				pipe(**_SCREAMING_SNAKE_CASE      ).images
        A_							:       Tuple	      =				image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 512, 3)
        A_							:       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









import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


_UpperCAmelCase										=					logging.get_logger(__name__)



class 				_UpperCamelCase       (						lowerCAmelCase_  ):

       def __init__(		self:			Tuple       , *_SCREAMING_SNAKE_CASE:			List[Any]       , **_SCREAMING_SNAKE_CASE:			List[Any]		)							->			None:




              """simple docstring"""


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

