





"""simple docstring"""
import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



def 					__lowerCamelCase       (							a_					:		Optional[Any]							)      ->				int:
      __SCREAMING_SNAKE_CASE       :List[Any]		    =  [tensor.shape for tensor in tensor_list]
      return all(shape == shapes[0] for shape in shapes[1:]							)






class  _SCREAMING_SNAKE_CASE(       A__   ,     A__   ,     A__   ,     unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  StableDiffusionLatentUpscalePipeline
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
           '''height''',
           '''width''',
           '''cross_attention_kwargs''',
           '''negative_prompt_embeds''',
           '''prompt_embeds''',
       }
       SCREAMING_SNAKE_CASE_       :				Optional[Any]     						=  PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
       SCREAMING_SNAKE_CASE_       :				Optional[Any]     						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       SCREAMING_SNAKE_CASE_       :				List[str]     						=  frozenset(
           []  )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
       SCREAMING_SNAKE_CASE_       :				Any     						=  frozenset([]  )

       SCREAMING_SNAKE_CASE_       :				Optional[int]     						=  True




       @property
       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  1
             __SCREAMING_SNAKE_CASE       :List[str]		    =  4
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  (16, 16)

             __SCREAMING_SNAKE_CASE       :Any		    =  floats_tensor((batch_size, num_channels) + sizes		,rng=random.Random(0							)							).to(__snake_case							)
             return image




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





             """simple docstring"""






             torch.manual_seed(0							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  UNetaDConditionModel(
                 act_fn='''gelu'''		,attention_head_dim=8		,norm_num_groups=__snake_case		,block_out_channels=[32, 32, 64, 64]		,time_cond_proj_dim=1_60		,conv_in_kernel=1		,conv_out_kernel=1		,cross_attention_dim=32		,down_block_types=(
                     '''KDownBlock2D''',
                     '''KCrossAttnDownBlock2D''',
                     '''KCrossAttnDownBlock2D''',
                     '''KCrossAttnDownBlock2D''',
                 )		,in_channels=8		,mid_block_type=__snake_case		,only_cross_attention=__snake_case		,out_channels=5		,resnet_time_scale_shift='''scale_shift'''		,time_embedding_type='''fourier'''		,timestep_post_act='''gelu'''		,up_block_types=('''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KUpBlock2D''')		,)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  AutoencoderKL(
                 block_out_channels=[32, 32, 64, 64]		,in_channels=3		,out_channels=3		,down_block_types=[
                     '''DownEncoderBlock2D''',
                     '''DownEncoderBlock2D''',
                     '''DownEncoderBlock2D''',
                     '''DownEncoderBlock2D''',
                 ]		,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		,latent_channels=4		,)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  EulerDiscreteScheduler(prediction_type='''sample'''							)
             __SCREAMING_SNAKE_CASE       :Tuple		    =  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		,hidden_act='''quick_gelu'''		,projection_dim=5_12		,)
             __SCREAMING_SNAKE_CASE       :Tuple		    =  CLIPTextModel(__snake_case							)
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  {
                 '''unet''': model.eval(),
                 '''vae''': vae.eval(),
                 '''scheduler''': scheduler,
                 '''text_encoder''': text_encoder,
                 '''tokenizer''': tokenizer,
             }

             return components




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=0							)      ->				Optional[int]:





             """simple docstring"""






             if str(__snake_case							).startswith('''mps'''							):
                   __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  torch.manual_seed(__snake_case							)
             else:
                   __SCREAMING_SNAKE_CASE       :List[Any]		    =  torch.Generator(device=__snake_case							).manual_seed(__snake_case							)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  {
                 '''prompt''': '''A painting of a squirrel eating a burger''',
                 '''image''': self.dummy_image.cpu(),
                 '''generator''': generator,
                 '''num_inference_steps''': 2,
                 '''output_type''': '''numpy''',
             }
             return inputs




       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Any		    =  '''cpu'''

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  self.get_dummy_components()
             __SCREAMING_SNAKE_CASE       :List[str]		    =  self.pipeline_class(**__snake_case							)
             pipe.to(__snake_case							)
             pipe.set_progress_bar_config(disable=__snake_case							)

             __SCREAMING_SNAKE_CASE       :Any		    =  self.get_dummy_inputs(__snake_case							)
             __SCREAMING_SNAKE_CASE       :int		    =  pipe(**__snake_case							).images
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  image[0, -3:, -3:, -1]

             self.assertEqual(image.shape		,(1, 2_56, 2_56, 3)							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  np.array(
                 [0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5]							)
             __SCREAMING_SNAKE_CASE       :str		    =  np.abs(image_slice.flatten() - expected_slice							).max()
             self.assertLessEqual(__snake_case		,1E-3							)




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






             super().test_attention_slicing_forward_pass(expected_max_diff=7E-3							)




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






             super().test_cpu_offload_forward_pass(expected_max_diff=3E-3							)




       def    _UpperCamelCase					(						self							)      ->				str:





             """simple docstring"""






             super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3							)




       def    _UpperCamelCase					(						self							)      ->				int:





             """simple docstring"""






             super().test_inference_batch_single_identical(expected_max_diff=7E-3							)




       def    _UpperCamelCase					(						self							)      ->				str:





             """simple docstring"""






             super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3E-3							)




       def    _UpperCamelCase					(						self							)      ->				Dict:





             """simple docstring"""






             super().test_save_load_local(expected_max_difference=3E-3							)




       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             super().test_save_load_optional_components(expected_max_difference=3E-3							)




       def    _UpperCamelCase					(						self							)      ->				Union[str, Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[Any]		    =  [
                 '''DDIMScheduler''',
                 '''DDPMScheduler''',
                 '''PNDMScheduler''',
                 '''HeunDiscreteScheduler''',
                 '''EulerAncestralDiscreteScheduler''',
                 '''KDPM2DiscreteScheduler''',
                 '''KDPM2AncestralDiscreteScheduler''',
                 '''DPMSolverSDEScheduler''',
             ]
             __SCREAMING_SNAKE_CASE       :str		    =  self.get_dummy_components()
             __SCREAMING_SNAKE_CASE       :Any		    =  self.pipeline_class(**__snake_case							)

             # make sure that PNDM does not need warm-up
             pipe.scheduler.register_to_config(skip_prk_steps=__snake_case							)

             pipe.to(__snake_case							)
             pipe.set_progress_bar_config(disable=__snake_case							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  self.get_dummy_inputs(__snake_case							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  2

             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  []
             for scheduler_enum in KarrasDiffusionSchedulers:
                   if scheduler_enum.name in skip_schedulers:
                         # no sigma schedulers are not supported
                         # no schedulers
                         continue

                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  getattr(__snake_case		,scheduler_enum.name							)
                   __SCREAMING_SNAKE_CASE       :List[Any]		    =  scheduler_cls.from_config(pipe.scheduler.config							)
                   __SCREAMING_SNAKE_CASE       :List[str]		    =  pipe(**__snake_case							)[0]
                   outputs.append(__snake_case							)

             assert check_same_shape(__snake_case							)






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




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





             """simple docstring"""






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




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  torch.manual_seed(33							)

             __SCREAMING_SNAKE_CASE       :Any		    =  StableDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''		,torch_dtype=torch.floataa							)
             pipe.to('''cuda'''							)

             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  StableDiffusionLatentUpscalePipeline.from_pretrained(
                 '''stabilityai/sd-x2-latent-upscaler'''		,torch_dtype=torch.floataa							)
             upscaler.to('''cuda'''							)

             __SCREAMING_SNAKE_CASE       :List[Any]		    =  '''a photo of an astronaut high resolution, unreal engine, ultra realistic'''

             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  pipe(__snake_case		,generator=__snake_case		,output_type='''latent'''							).images

             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  upscaler(
                 prompt=__snake_case		,image=__snake_case		,num_inference_steps=20		,guidance_scale=0		,generator=__snake_case		,output_type='''np'''		,).images[0]

             __SCREAMING_SNAKE_CASE       :Tuple		    =  load_numpy(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy'''							)
             assert np.abs((expected_image - image).mean()							) < 5E-2




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[Any]		    =  torch.manual_seed(33							)

             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  StableDiffusionLatentUpscalePipeline.from_pretrained(
                 '''stabilityai/sd-x2-latent-upscaler'''		,torch_dtype=torch.floataa							)
             upscaler.to('''cuda'''							)

             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  '''the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'''

             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  load_image(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png'''							)

             __SCREAMING_SNAKE_CASE       :List[str]		    =  upscaler(
                 prompt=__snake_case		,image=__snake_case		,num_inference_steps=20		,guidance_scale=0		,generator=__snake_case		,output_type='''np'''		,).images[0]

             __SCREAMING_SNAKE_CASE       :int		    =  load_numpy(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy'''							)
             assert np.abs((expected_image - image).max()							) < 5E-2






"""simple docstring"""
def 					__lowerCamelCase       (							a_					:		str			,       a_					:		str							)      ->				str:
      __SCREAMING_SNAKE_CASE       :int		    =  len(a_							)
      __SCREAMING_SNAKE_CASE       :int		    =  len(a_							)
      __SCREAMING_SNAKE_CASE       :int		    =  (
          first_str_length if first_str_length > second_str_length else second_str_length
      )
      __SCREAMING_SNAKE_CASE       :list		    =  []
      for char_count in range(a_							):
            if char_count < first_str_length:
                  output_list.append(first_str[char_count]							)
            if char_count < second_str_length:
                  output_list.append(second_str[char_count]							)
      return "".join(a_							)


if __name__ == "__main__":
  print(alternative_string_arrange("AB", "XYZ"), end=" ")