



'''simple docstring'''


import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
   from ... import PreTrainedTokenizerBase, TensorType

_lowerCamelCase	:       Any      	=	logging.get_logger(__name__)

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  """vision-encoder-decoder"""
    _SCREAMING_SNAKE_CASE	  =  True






    def __init__(  self      :					Any  ,						**UpperCamelCase__      :					str ):


       """simple docstring"""







       super().__init__(**__a )
       if "encoder" not in kwargs or "decoder" not in kwargs:
          raise ValueError(
              f"""A configuraton of type {self.model_type} cannot be instantiated because """
              f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" )

       UpperCamelCase					=  kwargs.pop('encoder' )
       UpperCamelCase					=  encoder_config.pop('model_type' )
       UpperCamelCase					=  kwargs.pop('decoder' )
       UpperCamelCase					=  decoder_config.pop('model_type' )

       UpperCamelCase					=  AutoConfig.for_model(__a  ,						**__a )
       UpperCamelCase					=  AutoConfig.for_model(__a  ,						**__a )
       UpperCamelCase					=  True






    @classmethod
    def  A       (  cls      :					Any  ,						UpperCamelCase__      :					int  ,						UpperCamelCase__      :					Union[str, Any]  ,						**UpperCamelCase__      :					Optional[Any] ):


       """simple docstring"""







       logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' )
       UpperCamelCase					=  True
       UpperCamelCase					=  True

       return cls(encoder=encoder_config.to_dict()  ,						decoder=decoder_config.to_dict()  ,						**__a )






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


       """simple docstring"""







       UpperCamelCase					=  copy.deepcopy(self.__dict__ )
       UpperCamelCase					=  self.encoder.to_dict()
       UpperCamelCase					=  self.decoder.to_dict()
       UpperCamelCase					=  self.__class__.model_type
       return output

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  version.parse("""1.11"""		)






    @property
    def  A       (  self      :					List[Any] ):


       """simple docstring"""







       return OrderedDict(
           [
               ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
           ] )






    @property
    def  A       (  self      :					Optional[int] ):


       """simple docstring"""







       return 1E-4






    @property
    def  A       (  self      :					Tuple ):


       """simple docstring"""







       return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} )

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    @property
    def  A       (  self      :					Any ):


       """simple docstring"""







       UpperCamelCase					=  OrderedDict()
       UpperCamelCase					=  {0: 'batch', 1: 'past_decoder_sequence + sequence'}
       UpperCamelCase					=  {0: 'batch', 1: 'past_decoder_sequence + sequence'}
       UpperCamelCase					=  {0: 'batch', 1: 'encoder_sequence'}

       return common_inputs






    def  A       (  self      :					List[Any]  ,						UpperCamelCase__      :					Optional[int]  ,						UpperCamelCase__      :					str = -1  ,						UpperCamelCase__      :					int = -1  ,						UpperCamelCase__      :					Dict = False  ,						UpperCamelCase__      :					Tuple = None  ,						):


       """simple docstring"""







       import torch

       UpperCamelCase					=  OrderedDict()

       UpperCamelCase					=  super().generate_dummy_inputs(
           __a  ,						batch_size=__a  ,						seq_length=__a  ,						is_pair=__a  ,						framework=__a )

       UpperCamelCase				,      UpperCamelCase					=  dummy_input['input_ids'].shape
       UpperCamelCase					=  (batch, encoder_sequence, self._config.encoder_hidden_size)
       UpperCamelCase					=  dummy_input.pop('input_ids' )
       UpperCamelCase					=  dummy_input.pop('attention_mask' )
       UpperCamelCase					=  torch.zeros(__a )

       return common_inputs

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    @property
    def  A       (  self      :					Dict ):


       """simple docstring"""







       pass






    def  A       (  self      :					Optional[int]  ,						UpperCamelCase__      :					Optional[int] ):


       """simple docstring"""







       return VisionEncoderDecoderEncoderOnnxConfig(__a )






    def  A       (  self      :					str  ,						UpperCamelCase__      :					Optional[Any]  ,						UpperCamelCase__      :					Optional[Any]  ,						UpperCamelCase__      :					Dict = "default" ):


       """simple docstring"""







       UpperCamelCase					=  encoder_config.hidden_size
       return VisionEncoderDecoderDecoderOnnxConfig(__a  ,						__a )



"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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






@skip_mps
class     _UpperCAmelCase(    lowerCamelCase      ,     lowerCamelCase      ,     unittest.TestCase	):
		lowercase__						=      StableDiffusionPanoramaPipeline
		lowercase__						=      TEXT_TO_IMAGE_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_BATCH_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_IMAGE_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_IMAGE_PARAMS



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							torch.manual_seed(0)
							_UpperCamelCase							 =  UNetaDConditionModel(
							    block_out_channels=(32, 64)				,		layers_per_block=1				,		sample_size=32				,		in_channels=4				,		out_channels=4				,		down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,		up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')				,		cross_attention_dim=32				,		)
							_UpperCamelCase							 =  DDIMScheduler()
							torch.manual_seed(0)
							_UpperCamelCase							 =  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				,		)
							torch.manual_seed(0)
							_UpperCamelCase							 =  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=10_00				,		)
							_UpperCamelCase							 =  CLIPTextModel(__a)
							_UpperCamelCase							 =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

							_UpperCamelCase							 =  {
							    '''unet''': unet,
							    '''scheduler''': scheduler,
							    '''vae''': vae,
							    '''text_encoder''': text_encoder,
							    '''tokenizer''': tokenizer,
							    '''safety_checker''': None,
							    '''feature_extractor''': None,
							}
							return components



		def 						UpperCAmelCase							(					self				,		__a				,		__a=0)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  torch.manual_seed(__a)
							_UpperCamelCase							 =  {
							    '''prompt''': '''a photo of the dolomites''',
							    '''generator''': generator,
							    # Setting height and width to None to prevent OOMs on CPU.
							    '''height''': None,
							    '''width''': None,
							    '''num_inference_steps''': 1,
							    '''guidance_scale''': 6.0,
							    '''output_type''': '''numpy''',
							}
							return inputs



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]
							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757])

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



		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							super().test_inference_batch_consistent(batch_sizes=[1, 2])



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							super().test_inference_batch_single_identical(batch_size=2				,		expected_max_diff=3.25e-3)



		def 						UpperCAmelCase							(					self)       ->       List[str]:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  '''french fries'''
							_UpperCamelCase							 =  sd_pipe(**__a				,		negative_prompt=__a)
							_UpperCamelCase							 =  output.images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

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

							_UpperCamelCase							 =  np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

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



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a				,		view_batch_size=2)
							_UpperCamelCase							 =  output.images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

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

							_UpperCamelCase							 =  np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

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



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  EulerAncestralDiscreteScheduler(
							    beta_start=0.0_0085				,		beta_end=0.012				,		beta_schedule='''scaled_linear''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

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

							_UpperCamelCase							 =  np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952])

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




		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  PNDMScheduler(
							    beta_start=0.0_0085				,		beta_end=0.012				,		beta_schedule='''scaled_linear'''				,		skip_prk_steps=__a)
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

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

							_UpperCamelCase							 =  np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539])

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






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



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



		def 						UpperCAmelCase							(					self				,		__a=0)       ->       List[str]:






							'''simple docstring'''
							_UpperCamelCase							 =  torch.manual_seed(__a)
							_UpperCamelCase							 =  {
							    '''prompt''': '''a photo of the dolomites''',
							    '''generator''': generator,
							    '''num_inference_steps''': 3,
							    '''guidance_scale''': 7.5,
							    '''output_type''': '''numpy''',
							}
							return inputs



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 5_12, 20_48, 3)

							_UpperCamelCase							 =  np.array(
							    [
							        0.3696_8392,
							        0.2702_5372,
							        0.3244_6766,
							        0.2837_9387,
							        0.3636_3274,
							        0.3073_3347,
							        0.2710_0027,
							        0.2705_4125,
							        0.2553_6096,
							    ])

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



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(
							    '''stabilityai/stable-diffusion-2-base'''				,		safety_checker=__a)
							_UpperCamelCase							 =  LMSDiscreteScheduler.from_config(pipe.scheduler.config)
							pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 5_12, 20_48, 3)

							_UpperCamelCase							 =  np.array(
							    [
							        [
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							        ]
							    ])

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



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  0

							def callback_fn(__a				,		__a				,		__a) -> None:
												_UpperCamelCase							 =  True
												nonlocal number_of_steps
												number_of_steps += 1
												if step == 1:
																	_UpperCamelCase							 =  latents.detach().cpu().numpy()
																	assert latents.shape == (1, 4, 64, 2_56)
																	_UpperCamelCase							 =  latents[0, -3:, -3:, -1]

																	_UpperCamelCase							 =  np.array(
																	    [
																	        0.1868_1869,
																	        0.3390_7816,
																	        0.536_1276,
																	        0.1443_2865,
																	        -0.0285_6611,
																	        -0.7394_1123,
																	        0.2339_7987,
																	        0.4732_2682,
																	        -0.3782_3164,
																	    ])
																	assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2
												elif step == 2:
																	_UpperCamelCase							 =  latents.detach().cpu().numpy()
																	assert latents.shape == (1, 4, 64, 2_56)
																	_UpperCamelCase							 =  latents[0, -3:, -3:, -1]

																	_UpperCamelCase							 =  np.array(
																	    [
																	        0.1853_9645,
																	        0.3398_7248,
																	        0.537_8559,
																	        0.1443_7142,
																	        -0.0245_5261,
																	        -0.733_8317,
																	        0.2399_0755,
																	        0.4735_6272,
																	        -0.378_6505,
																	    ])

																	assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2

							_UpperCamelCase							 =  False

							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							_UpperCamelCase							 =  pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							pipe(**__a				,		callback=__a				,		callback_steps=1)
							assert callback_fn.has_been_called
							assert number_of_steps == 3




		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							_UpperCamelCase							 =  pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing(1)
							pipe.enable_sequential_cpu_offload()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a)

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






