






"""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__       (							_lowerCamelCase       :		Optional[int] )      ->				Union[str, Any]:
  lowerCamelCase_         =						[tensor.shape for tensor in tensor_list]
  return all(shape == shapes[0] for shape in shapes[1:] )






class      a						(					a_  ,      a_  ,      a_  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     List[str]						= StableDiffusionLatentUpscalePipeline
    SCREAMING_SNAKE_CASE						:     Union[str, Any]						= TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
        "height",
        "width",
        "cross_attention_kwargs",
        "negative_prompt_embeds",
        "prompt_embeds",
    }
    SCREAMING_SNAKE_CASE						:     Union[str, Any]						= PipelineTesterMixin.required_optional_params - {"num_images_per_prompt"}
    SCREAMING_SNAKE_CASE						:     List[Any]						= TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
    SCREAMING_SNAKE_CASE						:     Optional[int]						= frozenset(
        []		)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
    SCREAMING_SNAKE_CASE						:     Optional[Any]						= frozenset([]		)

    SCREAMING_SNAKE_CASE						:     List[Any]						= True






    @property
    def    UpperCamelCase       (       self     :							Optional[int]					)     ->		Tuple:
      lowerCamelCase_         =						1
      lowerCamelCase_         =						4
      lowerCamelCase_         =						(16, 16)

      lowerCamelCase_         =						floats_tensor((batch_size, num_channels) + sizes       ,						rng=random.Random(0					)					).to(_lowerCamelCase					)
      return image






    def    UpperCamelCase       (       self     :							int					)     ->		str:
      torch.manual_seed(0					)
      lowerCamelCase_         =						UNetaDConditionModel(
          act_fn='gelu'       ,						attention_head_dim=8       ,						norm_num_groups=_lowerCamelCase       ,						block_out_channels=[32, 32, 64, 64]       ,						time_cond_proj_dim=160       ,						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=_lowerCamelCase       ,						only_cross_attention=_lowerCamelCase       ,						out_channels=5       ,						resnet_time_scale_shift='scale_shift'       ,						time_embedding_type='fourier'       ,						timestep_post_act='gelu'       ,						up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')       ,						)
      lowerCamelCase_         =						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       ,						)
      lowerCamelCase_         =						EulerDiscreteScheduler(prediction_type='sample'					)
      lowerCamelCase_         =						CLIPTextConfig(
          bos_token_id=0       ,						eos_token_id=2       ,						hidden_size=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       ,						hidden_act='quick_gelu'       ,						projection_dim=512       ,						)
      lowerCamelCase_         =						CLIPTextModel(_lowerCamelCase					)
      lowerCamelCase_         =						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

      lowerCamelCase_         =						{
          'unet': model.eval(),
          'vae': vae.eval(),
          'scheduler': scheduler,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
      }

      return components






    def    UpperCamelCase       (       self     :							Tuple       ,						__SCREAMING_SNAKE_CASE     :							Any       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=0					)     ->		Dict:
      if str(_lowerCamelCase					).startswith('mps'					):
        lowerCamelCase_         =						torch.manual_seed(_lowerCamelCase					)
      else:
        lowerCamelCase_         =						torch.Generator(device=_lowerCamelCase					).manual_seed(_lowerCamelCase					)
      lowerCamelCase_         =						{
          '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     :							List[str]					)     ->		Optional[int]:
      lowerCamelCase_         =						'cpu'

      lowerCamelCase_         =						self.get_dummy_components()
      lowerCamelCase_         =						self.pipeline_class(**_lowerCamelCase					)
      pipe.to(_lowerCamelCase					)
      pipe.set_progress_bar_config(disable=_lowerCamelCase					)

      lowerCamelCase_         =						self.get_dummy_inputs(_lowerCamelCase					)
      lowerCamelCase_         =						pipe(**_lowerCamelCase					).images
      lowerCamelCase_         =						image[0, -3:, -3:, -1]

      self.assertEqual(image.shape       ,						(1, 256, 256, 3)					)
      lowerCamelCase_         =						np.array(
          [0.47_222_412, 0.41_921_633, 0.44_717_434, 0.46_874_192, 0.42_588_258, 0.46_150_726, 0.4_677_534, 0.45_583_832, 0.48_579_055]					)
      lowerCamelCase_         =						np.abs(image_slice.flatten() - expected_slice					).max()
      self.assertLessEqual(_lowerCamelCase       ,						1e-3					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Any:
      super().test_attention_slicing_forward_pass(expected_max_diff=7e-3					)






    def    UpperCamelCase       (       self     :							str					)     ->		Dict:
      super().test_cpu_offload_forward_pass(expected_max_diff=3e-3					)






    def    UpperCamelCase       (       self     :							Any					)     ->		List[str]:
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)






    def    UpperCamelCase       (       self     :							str					)     ->		Optional[Any]:
      super().test_inference_batch_single_identical(expected_max_diff=7e-3					)






    def    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[int]:
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3					)






    def    UpperCamelCase       (       self     :							str					)     ->		str:
      super().test_save_load_local(expected_max_difference=3e-3					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		str:
      super().test_save_load_optional_components(expected_max_difference=3e-3					)






    def    UpperCamelCase       (       self     :							Any					)     ->		Union[str, Any]:
      lowerCamelCase_         =						[
          'DDIMScheduler',
          'DDPMScheduler',
          'PNDMScheduler',
          'HeunDiscreteScheduler',
          'EulerAncestralDiscreteScheduler',
          'KDPM2DiscreteScheduler',
          'KDPM2AncestralDiscreteScheduler',
          'DPMSolverSDEScheduler',
      ]
      lowerCamelCase_         =						self.get_dummy_components()
      lowerCamelCase_         =						self.pipeline_class(**_lowerCamelCase					)

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

      pipe.to(_lowerCamelCase					)
      pipe.set_progress_bar_config(disable=_lowerCamelCase					)
      lowerCamelCase_         =						self.get_dummy_inputs(_lowerCamelCase					)
      lowerCamelCase_         =						2

      lowerCamelCase_         =						[]
      for scheduler_enum in KarrasDiffusionSchedulers:
        if scheduler_enum.name in skip_schedulers:
          # no sigma schedulers are not supported
          # no schedulers
          continue

        lowerCamelCase_         =						getattr(_lowerCamelCase       ,						scheduler_enum.name					)
        lowerCamelCase_         =						scheduler_cls.from_config(pipe.scheduler.config					)
        lowerCamelCase_         =						pipe(**_lowerCamelCase					)[0]
        outputs.append(_lowerCamelCase					)

      assert check_same_shape(_lowerCamelCase					)






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






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		Optional[Any]:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()






    def    UpperCamelCase       (       self     :							str					)     ->		Union[str, Any]:
      lowerCamelCase_         =						torch.manual_seed(33					)

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

      lowerCamelCase_         =						StableDiffusionLatentUpscalePipeline.from_pretrained(
          'stabilityai/sd-x2-latent-upscaler'       ,						torch_dtype=torch.floataa					)
      upscaler.to('cuda'					)

      lowerCamelCase_         =						'a photo of an astronaut high resolution, unreal engine, ultra realistic'

      lowerCamelCase_         =						pipe(_lowerCamelCase       ,						generator=_lowerCamelCase       ,						output_type='latent'					).images

      lowerCamelCase_         =						upscaler(
          prompt=_lowerCamelCase       ,						image=_lowerCamelCase       ,						num_inference_steps=20       ,						guidance_scale=0       ,						generator=_lowerCamelCase       ,						output_type='np'       ,						).images[0]

      lowerCamelCase_         =						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]					)     ->		Optional[int]:
      lowerCamelCase_         =						torch.manual_seed(33					)

      lowerCamelCase_         =						StableDiffusionLatentUpscalePipeline.from_pretrained(
          'stabilityai/sd-x2-latent-upscaler'       ,						torch_dtype=torch.floataa					)
      upscaler.to('cuda'					)

      lowerCamelCase_         =						'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'

      lowerCamelCase_         =						load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png'					)

      lowerCamelCase_         =						upscaler(
          prompt=_lowerCamelCase       ,						image=_lowerCamelCase       ,						num_inference_steps=20       ,						guidance_scale=0       ,						generator=_lowerCamelCase       ,						output_type='np'       ,						).images[0]

      lowerCamelCase_         =						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"""



_UpperCamelCase		:  List[str]						=		{
    'meter': 'm',
    'kilometer': 'km',
    'megametre': 'Mm',
    'gigametre': 'Gm',
    'terametre': 'Tm',
    'petametre': 'Pm',
    'exametre': 'Em',
    'zettametre': 'Zm',
    'yottametre': 'Ym',
}
# Exponent of the factor(meter)
_UpperCamelCase		:  str						=		{
    'm': 0,
    'km': 3,
    'Mm': 6,
    'Gm': 9,
    'Tm': 1_2,
    'Pm': 1_5,
    'Em': 1_8,
    'Zm': 2_1,
    'Ym': 2_4,
}
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  float		,					__snake_case			:  str		,					__snake_case			:  str    ):





  '''simple docstring'''





  lowercase							    =       from_type.lower().strip('s'    )
  lowercase							    =       to_type.lower().strip('s'    )

  lowercase							    =       UNIT_SYMBOL.get(__snake_case		,					__snake_case    )
  lowercase							    =       UNIT_SYMBOL.get(__snake_case		,					__snake_case    )

  if from_sanitized not in METRIC_CONVERSION:
    lowercase							    =       (
        f'Invalid \'from_type\' value: {from_type!r}.\n'
        f'Conversion abbreviations are: {", ".join(__snake_case    )}'
    )
    raise ValueError(__snake_case    )
  if to_sanitized not in METRIC_CONVERSION:
    lowercase							    =       (
        f'Invalid \'to_type\' value: {to_type!r}.\n'
        f'Conversion abbreviations are: {", ".join(__snake_case    )}'
    )
    raise ValueError(__snake_case    )
  lowercase							    =       METRIC_CONVERSION[from_sanitized]
  lowercase							    =       METRIC_CONVERSION[to_sanitized]
  lowercase							    =       1

  if from_exponent > to_exponent:
    lowercase							    =       from_exponent - to_exponent
  else:
    lowercase							    =       -(to_exponent - from_exponent)

  return value * pow(10		,					__snake_case    )


if __name__ == "__main__":
    from doctest import testmod

    testmod()


