






"""simple docstring"""


import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 						snake_case  (  UpperCAmelCase       ,			unittest.TestCase	):
    __magic_name__   					=					UnCLIPImageVariationPipeline
    __magic_name__   					=					IMAGE_VARIATION_PARAMS - {'''height''', '''width''', '''guidance_scale'''}
    __magic_name__   					=					IMAGE_VARIATION_BATCH_PARAMS

    __magic_name__   					=					[
        '''generator''',
        '''return_dict''',
        '''decoder_num_inference_steps''',
        '''super_res_num_inference_steps''',
    ]
    __magic_name__   					=					False





    @property
    def     lowerCamelCase__				(							self     : Optional[Any]      ):


      '''simple docstring'''




      return 3_2





    @property
    def     lowerCamelCase__				(							self     : Union[str, Any]      ):


      '''simple docstring'''




      return 3_2





    @property
    def     lowerCamelCase__				(							self     : int      ):


      '''simple docstring'''




      return self.time_input_dim





    @property
    def     lowerCamelCase__				(							self     : Union[str, Any]      ):


      '''simple docstring'''




      return self.time_input_dim * 4





    @property
    def     lowerCamelCase__				(							self     : Any      ):


      '''simple docstring'''




      return 1_0_0





    @property
    def     lowerCamelCase__				(							self     : str      ):


      '''simple docstring'''




      a					:      str    =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )
      return tokenizer





    @property
    def     lowerCamelCase__				(							self     : Any      ):


      '''simple docstring'''




      torch.manual_seed(0      )
      a					:      str    =       CLIPTextConfig(
          bos_token_id=0    ,		eos_token_id=2    ,		hidden_size=self.text_embedder_hidden_size    ,		projection_dim=self.text_embedder_hidden_size    ,		intermediate_size=3_7    ,		layer_norm_eps=1E-05    ,		num_attention_heads=4    ,		num_hidden_layers=5    ,		pad_token_id=1    ,		vocab_size=1_0_0_0    ,		)
      return CLIPTextModelWithProjection(A      )





    @property
    def     lowerCamelCase__				(							self     : Optional[Any]      ):


      '''simple docstring'''




      torch.manual_seed(0      )
      a					:      Optional[Any]    =       CLIPVisionConfig(
          hidden_size=self.text_embedder_hidden_size    ,		projection_dim=self.text_embedder_hidden_size    ,		num_hidden_layers=5    ,		num_attention_heads=4    ,		image_size=3_2    ,		intermediate_size=3_7    ,		patch_size=1    ,		)
      return CLIPVisionModelWithProjection(A      )





    @property
    def     lowerCamelCase__				(							self     : str      ):


      '''simple docstring'''




      torch.manual_seed(0      )

      a					:      Dict    =       {
          'clip_embeddings_dim': self.text_embedder_hidden_size,
          'time_embed_dim': self.time_embed_dim,
          'cross_attention_dim': self.cross_attention_dim,
      }

      a					:      List[str]    =       UnCLIPTextProjModel(**A      )
      return model





    @property
    def     lowerCamelCase__				(							self     : str      ):


      '''simple docstring'''




      torch.manual_seed(0      )

      a					:      Tuple    =       {
          'sample_size': 3_2,
          # RGB in channels
          'in_channels': 3,
          # Out channels is double in channels because predicts mean and variance
          'out_channels': 6,
          'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'),
          'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'),
          'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn',
          'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2),
          'layers_per_block': 1,
          'cross_attention_dim': self.cross_attention_dim,
          'attention_head_dim': 4,
          'resnet_time_scale_shift': 'scale_shift',
          'class_embed_type': 'identity',
      }

      a					:      List[str]    =       UNetaDConditionModel(**A      )
      return model





    @property
    def     lowerCamelCase__				(							self     : str      ):


      '''simple docstring'''




      return {
          "sample_size": 6_4,
          "layers_per_block": 1,
          "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
          "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
          "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
          "in_channels": 6,
          "out_channels": 3,
      }





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


      '''simple docstring'''




      torch.manual_seed(0      )

      a					:      Tuple    =       UNetaDModel(**self.dummy_super_res_kwargs      )
      return model





    @property
    def     lowerCamelCase__				(							self     : Dict      ):


      '''simple docstring'''




      torch.manual_seed(1      )

      a					:      Optional[Any]    =       UNetaDModel(**self.dummy_super_res_kwargs      )
      return model





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


      '''simple docstring'''




      a					:      Optional[Any]    =       self.dummy_decoder
      a					:      Optional[int]    =       self.dummy_text_proj
      a					:      List[Any]    =       self.dummy_text_encoder
      a					:      List[str]    =       self.dummy_tokenizer
      a					:      Dict    =       self.dummy_super_res_first
      a					:      List[str]    =       self.dummy_super_res_last

      a					:      Dict    =       UnCLIPScheduler(
          variance_type='learned_range'    ,		prediction_type='epsilon'    ,		num_train_timesteps=1_0_0_0    ,		)

      a					:      Optional[int]    =       UnCLIPScheduler(
          variance_type='fixed_small_log'    ,		prediction_type='epsilon'    ,		num_train_timesteps=1_0_0_0    ,		)

      a					:      Dict    =       CLIPImageProcessor(crop_size=3_2    ,		size=3_2      )

      a					:      Optional[int]    =       self.dummy_image_encoder

      return {
          "decoder": decoder,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "text_proj": text_proj,
          "feature_extractor": feature_extractor,
          "image_encoder": image_encoder,
          "super_res_first": super_res_first,
          "super_res_last": super_res_last,
          "decoder_scheduler": decoder_scheduler,
          "super_res_scheduler": super_res_scheduler,
      }





    def     lowerCamelCase__				(							self     : int    ,		A     : str    ,		A     : int=0    ,		A     : Tuple=True      ):


      '''simple docstring'''




      a					:      Dict    =       floats_tensor((1, 3, 3_2, 3_2)    ,		rng=random.Random(A      )      ).to(A      )
      if str(A      ).startswith('mps'      ):
        a					:      Tuple    =       torch.manual_seed(A      )
      else:
        a					:      Optional[int]    =       torch.Generator(device=A      ).manual_seed(A      )

      if pil_image:
        a					:      int    =       input_image * 0.5 + 0.5
        a					:      Union[str, Any]    =       input_image.clamp(0    ,		1      )
        a					:      int    =       input_image.cpu().permute(0    ,		2    ,		3    ,		1      ).float().numpy()
        a					:      Tuple    =       DiffusionPipeline.numpy_to_pil(A      )[0]

      return {
          "image": input_image,
          "generator": generator,
          "decoder_num_inference_steps": 2,
          "super_res_num_inference_steps": 2,
          "output_type": "np",
      }





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


      '''simple docstring'''




      a					:      Optional[Any]    =       'cpu'

      a					:      Optional[int]    =       self.get_dummy_components()

      a					:      str    =       self.pipeline_class(**A      )
      a					:      List[Any]    =       pipe.to(A      )

      pipe.set_progress_bar_config(disable=A      )

      a					:      List[str]    =       self.get_dummy_inputs(A    ,		pil_image=A      )

      a					:      int    =       pipe(**A      )
      a					:      Optional[int]    =       output.images

      a					:      List[Any]    =       self.get_dummy_inputs(A    ,		pil_image=A      )

      a					:      int    =       pipe(
          **A    ,		return_dict=A    ,		)[0]

      a					:      Any    =       image[0, -3:, -3:, -1]
      a					:      int    =       image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 6_4, 6_4, 3)

      a					:      List[str]    =       np.array(
          [
              0.99_97,
              0.00_02,
              0.99_97,
              0.99_97,
              0.99_69,
              0.00_23,
              0.99_97,
              0.99_69,
              0.99_70,
          ]      )

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





    def     lowerCamelCase__				(							self     : Dict      ):


      '''simple docstring'''




      a					:      int    =       'cpu'

      a					:      List[Any]    =       self.get_dummy_components()

      a					:      List[str]    =       self.pipeline_class(**A      )
      a					:      int    =       pipe.to(A      )

      pipe.set_progress_bar_config(disable=A      )

      a					:      str    =       self.get_dummy_inputs(A    ,		pil_image=A      )

      a					:      List[Any]    =       pipe(**A      )
      a					:      List[Any]    =       output.images

      a					:      Union[str, Any]    =       self.get_dummy_inputs(A    ,		pil_image=A      )

      a					:      int    =       pipe(
          **A    ,		return_dict=A    ,		)[0]

      a					:      Dict    =       image[0, -3:, -3:, -1]
      a					:      List[Any]    =       image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 6_4, 6_4, 3)

      a					:      Any    =       np.array([0.99_97, 0.00_03, 0.99_97, 0.99_97, 0.99_70, 0.00_24, 0.99_97, 0.99_71, 0.99_71]      )

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





    def     lowerCamelCase__				(							self     : List[Any]      ):


      '''simple docstring'''




      a					:      Optional[int]    =       'cpu'

      a					:      Optional[Any]    =       self.get_dummy_components()

      a					:      Tuple    =       self.pipeline_class(**A      )
      a					:      Tuple    =       pipe.to(A      )

      pipe.set_progress_bar_config(disable=A      )

      a					:      Union[str, Any]    =       self.get_dummy_inputs(A    ,		pil_image=A      )
      a					:      List[str]    =       [
          pipeline_inputs['image'],
          pipeline_inputs['image'],
      ]

      a					:      List[Any]    =       pipe(**A      )
      a					:      int    =       output.images

      a					:      List[str]    =       self.get_dummy_inputs(A    ,		pil_image=A      )
      a					:      Tuple    =       [
          tuple_pipeline_inputs['image'],
          tuple_pipeline_inputs['image'],
      ]

      a					:      Any    =       pipe(
          **A    ,		return_dict=A    ,		)[0]

      a					:      Dict    =       image[0, -3:, -3:, -1]
      a					:      List[str]    =       image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (2, 6_4, 6_4, 3)

      a					:      Union[str, Any]    =       np.array(
          [
              0.99_97,
              0.99_89,
              0.00_08,
              0.00_21,
              0.99_60,
              0.00_18,
              0.00_14,
              0.00_02,
              0.99_33,
          ]      )

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





    def     lowerCamelCase__				(							self     : Optional[int]      ):


      '''simple docstring'''




      a					:      List[str]    =       torch.device('cpu'      )






      class 						snake_case  :
          __magic_name__   					=					1




      a					:      Tuple    =       self.get_dummy_components()

      a					:      Tuple    =       self.pipeline_class(**A      )
      a					:      Optional[Any]    =       pipe.to(A      )

      pipe.set_progress_bar_config(disable=A      )

      a					:      Union[str, Any]    =       torch.Generator(device=A      ).manual_seed(0      )
      a					:      Any    =       pipe.decoder.dtype
      a					:      int    =       1

      a					:      List[str]    =       (
          batch_size,
          pipe.decoder.config.in_channels,
          pipe.decoder.config.sample_size,
          pipe.decoder.config.sample_size,
      )
      a					:      List[str]    =       pipe.prepare_latents(
          A    ,		dtype=A    ,		device=A    ,		generator=A    ,		latents=A    ,		scheduler=DummyScheduler()      )

      a					:      List[str]    =       (
          batch_size,
          pipe.super_res_first.config.in_channels // 2,
          pipe.super_res_first.config.sample_size,
          pipe.super_res_first.config.sample_size,
      )
      a					:      Tuple    =       pipe.prepare_latents(
          A    ,		dtype=A    ,		device=A    ,		generator=A    ,		latents=A    ,		scheduler=DummyScheduler()      )

      a					:      int    =       self.get_dummy_inputs(A    ,		pil_image=A      )

      a					:      Dict    =       pipe(
          **A    ,		decoder_latents=A    ,		super_res_latents=A      ).images

      a					:      Dict    =       self.get_dummy_inputs(A    ,		pil_image=A      )
      # Don't pass image, instead pass embedding
      a					:      int    =       pipeline_inputs.pop('image'      )
      a					:      Optional[Any]    =       pipe.image_encoder(A      ).image_embeds

      a					:      Tuple    =       pipe(
          **A    ,		decoder_latents=A    ,		super_res_latents=A    ,		image_embeddings=A    ,		).images

      # make sure passing text embeddings manually is identical
      assert np.abs(img_out_a - img_out_a      ).max() < 1E-4





    @skip_mps
    def     lowerCamelCase__				(							self     : Union[str, Any]      ):


      '''simple docstring'''




      a					:      int    =       torch_device == 'cpu'

      # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
      a					:      Tuple    =       1E-2

      self._test_attention_slicing_forward_pass(
          test_max_difference=A    ,		expected_max_diff=A      )





    @skip_mps
    def     lowerCamelCase__				(							self     : int      ):


      '''simple docstring'''




      a					:      str    =       torch_device == 'cpu'
      a					:      Any    =       True
      a					:      int    =       [
          'decoder_num_inference_steps',
          'super_res_num_inference_steps',
      ]

      self._test_inference_batch_single_identical(
          test_max_difference=A    ,		relax_max_difference=A    ,		additional_params_copy_to_batched_inputs=A    ,		)





    def     lowerCamelCase__				(							self     : Any      ):


      '''simple docstring'''




      a					:      int    =       [
          'decoder_num_inference_steps',
          'super_res_num_inference_steps',
      ]

      if torch_device == "mps":
        # TODO: MPS errors with larger batch sizes
        a					:      Tuple    =       [2, 3]
        self._test_inference_batch_consistent(
            batch_sizes=A    ,		additional_params_copy_to_batched_inputs=A    ,		)
      else:
        self._test_inference_batch_consistent(
            additional_params_copy_to_batched_inputs=A      )





    @skip_mps
    def     lowerCamelCase__				(							self     : Optional[int]      ):


      '''simple docstring'''




      return super().test_dict_tuple_outputs_equivalent()





    @skip_mps
    def     lowerCamelCase__				(							self     : Union[str, Any]      ):


      '''simple docstring'''




      return super().test_save_load_local()





    @skip_mps
    def     lowerCamelCase__				(							self     : Optional[int]      ):


      '''simple docstring'''




      return super().test_save_load_optional_components()






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





    def     lowerCamelCase__				(							self     : Optional[int]      ):


      '''simple docstring'''




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





    def     lowerCamelCase__				(							self     : Dict      ):


      '''simple docstring'''




      a					:      Optional[Any]    =       load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'      )
      a					:      Tuple    =       load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
          '/unclip/karlo_v1_alpha_cat_variation_fp16.npy'      )

      a					:      Optional[int]    =       UnCLIPImageVariationPipeline.from_pretrained(
          'kakaobrain/karlo-v1-alpha-image-variations'    ,		torch_dtype=torch.floataa      )
      a					:      List[Any]    =       pipeline.to(A      )
      pipeline.set_progress_bar_config(disable=A      )

      a					:      int    =       torch.Generator(device='cpu'      ).manual_seed(0      )
      a					:      Dict    =       pipeline(
          A    ,		generator=A    ,		output_type='np'    ,		)

      a					:      int    =       output.images[0]

      assert image.shape == (2_5_6, 2_5_6, 3)

      assert_mean_pixel_difference(A    ,		A    ,		1_5      )












"""simple docstring"""


_UpperCamelCase    :   List[Any]   			=						8.31_44_62  # Unit - J mol-1 K-1




def       snake_case  (A_				:float     ,      A_				:float     ,      A_				:float				):







  '''simple docstring'''

  if moles < 0 or kelvin < 0 or volume < 0:
    raise ValueError('Invalid inputs. Enter positive value.'				)
  return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume




def       snake_case  (A_				:float     ,      A_				:float     ,      A_				:float				):







  '''simple docstring'''

  if moles < 0 or kelvin < 0 or pressure < 0:
    raise ValueError('Invalid inputs. Enter positive value.'				)
  return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


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

   testmod()




