
"""simple docstring"""







from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize






class      __a      (       lowerCAmelCase_      ):
       _lowerCamelCase				:				Union[str, Any]   			=      1
       _lowerCamelCase				:				Optional[Any]   			=      2
       _lowerCamelCase				:				Any   			=      3







       def __repr__(       self		):



          '''simple docstring'''

          return f'''{self.__class__.__name__}.{self.name}'''



def       __UpperCAmelCase		(		a_      :		tuple[int, int]     ,	a_      :		int     ,	a_      :		int					)  ->							float:
   _UpperCAmelCase						,				_UpperCAmelCase 						=       point
   return degrees(atana(y - miny     ,	x - minx					)					)
def       __UpperCAmelCase		(		a_      :		tuple[int, int]     ,	a_      :		tuple[int, int]     ,	a_      :		tuple[int, int]					)  ->							Direction:
   _UpperCAmelCase						,				_UpperCAmelCase 						=       starting
   _UpperCAmelCase						,				_UpperCAmelCase 						=       via
   _UpperCAmelCase						,				_UpperCAmelCase 						=       target
   _UpperCAmelCase 						=       degrees(atana(ya - ya     ,	xa - xa					)					)
   via_angle %= 3_60
   _UpperCAmelCase 						=       degrees(atana(ya - ya     ,	xa - xa					)					)
   target_angle %= 3_60
   # t-
   #  \ \
   #   \ v
   #    \|
   #     s
   # via_angle is always lower than target_angle, if direction is left.
   # If they are same, it means they are on a same line of convex hull.
   if target_angle > via_angle:
      return Direction.left
   elif target_angle == via_angle:
      return Direction.straight
   else:
      return Direction.right


def       __UpperCAmelCase		(		a_      :		list[tuple[int, int]]					)  ->							list[tuple[int, int]]:

   if len(a_					) <= 2:
      # There is no convex hull
      raise ValueError("graham_scan: argument must contain more than 3 points."					)
   if len(a_					) == 3:
      return points
   # find the lowest and the most left point
   _UpperCAmelCase 						=       0
   _UpperCAmelCase						,				_UpperCAmelCase 						=       maxsize, maxsize
   for i, point in enumerate(a_					):
      _UpperCAmelCase 						=       point[0]
      _UpperCAmelCase 						=       point[1]
      if y < miny:
         _UpperCAmelCase 						=       y
         _UpperCAmelCase 						=       x
         _UpperCAmelCase 						=       i
      if y == miny and x < minx:
         _UpperCAmelCase 						=       x
         _UpperCAmelCase 						=       i

    # remove the lowest and the most left point from points for preparing for sort
   points.pop(a_					)

   _UpperCAmelCase 						=       sorted(a_     ,	key=lambda a_					: angle_comparer(a_     ,	a_     ,	a_					)					)
   # This insert actually costs complexity,
   # and you should instead add (minx, miny) into stack later.
   # I'm using insert just for easy understanding.
   sorted_points.insert(0     ,	(minx, miny)					)

   _UpperCAmelCase 						=       deque()
   stack.append(sorted_points[0]					)
   stack.append(sorted_points[1]					)
   stack.append(sorted_points[2]					)
   # In any ways, the first 3 points line are towards left.
   # Because we sort them the angle from minx, miny.
   _UpperCAmelCase 						=       Direction.left

   for i in range(3     ,	len(a_					)					):
      while True:
         _UpperCAmelCase 						=       stack[-2]
         _UpperCAmelCase 						=       stack[-1]
         _UpperCAmelCase 						=       sorted_points[i]
         _UpperCAmelCase 						=       check_direction(a_     ,	a_     ,	a_					)

         if next_direction == Direction.left:
            _UpperCAmelCase 						=       Direction.left
            break
         if next_direction == Direction.straight:
            if current_direction == Direction.left:
               # We keep current_direction as left.
               # Because if the straight line keeps as straight,
               # we want to know if this straight line is towards left.
               break
            elif current_direction == Direction.right:
               # If the straight line is towards right,
               # every previous points on those straigh line is not convex hull.
               stack.pop()
         if next_direction == Direction.right:
            stack.pop()
      stack.append(sorted_points[i]					)
   return list(a_					)



"""simple docstring"""







import gc
import unittest

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

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, 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_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class      __a      (       lowerCAmelCase_					,						unittest.TestCase      ):
       _lowerCamelCase				:				int   			=      UnCLIPPipeline
       _lowerCamelCase				:				Any   			=      TEXT_TO_IMAGE_PARAMS - {
           'negative_prompt',
           'height',
           'width',
           'negative_prompt_embeds',
           'guidance_scale',
           'prompt_embeds',
           'cross_attention_kwargs',
       }
       _lowerCamelCase				:				Optional[int]   			=      TEXT_TO_IMAGE_BATCH_PARAMS
       _lowerCamelCase				:				Dict   			=      [
           'generator',
           'return_dict',
           'prior_num_inference_steps',
           'decoder_num_inference_steps',
           'super_res_num_inference_steps',
       ]
       _lowerCamelCase				:				Any   			=      False







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return 32







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return 32







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return self.time_input_dim







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return self.time_input_dim * 4







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return 100







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)
          return tokenizer







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(0		)
          _UpperCAmelCase 						=       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=37				,layer_norm_eps=1e-05				,num_attention_heads=4				,num_hidden_layers=5				,pad_token_id=1				,vocab_size=1000				,)
          return CLIPTextModelWithProjection(lowerCamelCase_		)







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(0		)

          _UpperCAmelCase 						=       {
              "num_attention_heads": 2,
              "attention_head_dim": 12,
              "embedding_dim": self.text_embedder_hidden_size,
              "num_layers": 1,
          }

          _UpperCAmelCase 						=       PriorTransformer(**lowerCamelCase_		)
          return model







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(0		)

          _UpperCAmelCase 						=       {
              "clip_embeddings_dim": self.text_embedder_hidden_size,
              "time_embed_dim": self.time_embed_dim,
              "cross_attention_dim": self.cross_attention_dim,
          }

          _UpperCAmelCase 						=       UnCLIPTextProjModel(**lowerCamelCase_		)
          return model







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(0		)

          _UpperCAmelCase 						=       {
              "sample_size": 32,
              # 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",
          }

          _UpperCAmelCase 						=       UNetaDConditionModel(**lowerCamelCase_		)
          return model







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          return {
              "sample_size": 64,
              "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  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(0		)

          _UpperCAmelCase 						=       UNetaDModel(**self.dummy_super_res_kwargs		)
          return model







       @property
       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.manual_seed(1		)

          _UpperCAmelCase 						=       UNetaDModel(**self.dummy_super_res_kwargs		)
          return model







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.dummy_prior
          _UpperCAmelCase 						=       self.dummy_decoder
          _UpperCAmelCase 						=       self.dummy_text_proj
          _UpperCAmelCase 						=       self.dummy_text_encoder
          _UpperCAmelCase 						=       self.dummy_tokenizer
          _UpperCAmelCase 						=       self.dummy_super_res_first
          _UpperCAmelCase 						=       self.dummy_super_res_last

          _UpperCAmelCase 						=       UnCLIPScheduler(
              variance_type="fixed_small_log"				,prediction_type="sample"				,num_train_timesteps=1000				,clip_sample_range=5.0				,)

          _UpperCAmelCase 						=       UnCLIPScheduler(
              variance_type="learned_range"				,prediction_type="epsilon"				,num_train_timesteps=1000				,)

          _UpperCAmelCase 						=       UnCLIPScheduler(
              variance_type="fixed_small_log"				,prediction_type="epsilon"				,num_train_timesteps=1000				,)

          _UpperCAmelCase 						=       {
              "prior": prior,
              "decoder": decoder,
              "text_proj": text_proj,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "super_res_first": super_res_first,
              "super_res_last": super_res_last,
              "prior_scheduler": prior_scheduler,
              "decoder_scheduler": decoder_scheduler,
              "super_res_scheduler": super_res_scheduler,
          }

          return components







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_=0		):



          '''simple docstring'''

          if str(lowerCamelCase_		).startswith("mps"		):
             _UpperCAmelCase 						=       torch.manual_seed(lowerCamelCase_		)
          else:
             _UpperCAmelCase 						=       torch.Generator(device=lowerCamelCase_		).manual_seed(lowerCamelCase_		)
          _UpperCAmelCase 						=       {
              "prompt": "horse",
              "generator": generator,
              "prior_num_inference_steps": 2,
              "decoder_num_inference_steps": 2,
              "super_res_num_inference_steps": 2,
              "output_type": "numpy",
          }
          return inputs







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       "cpu"

          _UpperCAmelCase 						=       self.get_dummy_components()

          _UpperCAmelCase 						=       self.pipeline_class(**lowerCamelCase_		)
          _UpperCAmelCase 						=       pipe.to(lowerCamelCase_		)

          pipe.set_progress_bar_config(disable=lowerCamelCase_		)

          _UpperCAmelCase 						=       pipe(**self.get_dummy_inputs(lowerCamelCase_		)		)
          _UpperCAmelCase 						=       output.images

          _UpperCAmelCase 						=       pipe(
              **self.get_dummy_inputs(lowerCamelCase_		)				,return_dict=lowerCamelCase_				,)[0]

          _UpperCAmelCase 						=       image[0, -3:, -3:, -1]
          _UpperCAmelCase 						=       image_from_tuple[0, -3:, -3:, -1]

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

          _UpperCAmelCase 						=       np.array(
              [
                  0.9_9_9_7,
                  0.9_9_8_8,
                  0.0_0_2_8,
                  0.9_9_9_7,
                  0.9_9_8_4,
                  0.9_9_6_5,
                  0.0_0_2_9,
                  0.9_9_8_6,
                  0.0_0_2_5,
              ]		)

          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  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       torch.device("cpu"		)






          class      __a      :
                 _lowerCamelCase				:				Optional[Any]   			=      1



          _UpperCAmelCase 						=       self.get_dummy_components()

          _UpperCAmelCase 						=       self.pipeline_class(**lowerCamelCase_		)
          _UpperCAmelCase 						=       pipe.to(lowerCamelCase_		)

          _UpperCAmelCase 						=       components["prior"]
          _UpperCAmelCase 						=       components["decoder"]
          _UpperCAmelCase 						=       components["super_res_first"]
          _UpperCAmelCase 						=       components["tokenizer"]
          _UpperCAmelCase 						=       components["text_encoder"]

          _UpperCAmelCase 						=       torch.Generator(device=lowerCamelCase_		).manual_seed(0		)
          _UpperCAmelCase 						=       prior.dtype
          _UpperCAmelCase 						=       1

          _UpperCAmelCase 						=       (batch_size, prior.config.embedding_dim)
          _UpperCAmelCase 						=       pipe.prepare_latents(
              lowerCamelCase_				,dtype=lowerCamelCase_				,device=lowerCamelCase_				,generator=lowerCamelCase_				,latents=lowerCamelCase_				,scheduler=DummyScheduler()		)
          _UpperCAmelCase 						=       (batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
          _UpperCAmelCase 						=       pipe.prepare_latents(
              lowerCamelCase_				,dtype=lowerCamelCase_				,device=lowerCamelCase_				,generator=lowerCamelCase_				,latents=lowerCamelCase_				,scheduler=DummyScheduler()		)

          _UpperCAmelCase 						=       (
              batch_size,
              super_res_first.config.in_channels // 2,
              super_res_first.config.sample_size,
              super_res_first.config.sample_size,
          )
          _UpperCAmelCase 						=       pipe.prepare_latents(
              lowerCamelCase_				,dtype=lowerCamelCase_				,device=lowerCamelCase_				,generator=lowerCamelCase_				,latents=lowerCamelCase_				,scheduler=DummyScheduler()		)

          pipe.set_progress_bar_config(disable=lowerCamelCase_		)

          _UpperCAmelCase 						=       "this is a prompt example"

          _UpperCAmelCase 						=       torch.Generator(device=lowerCamelCase_		).manual_seed(0		)
          _UpperCAmelCase 						=       pipe(
              [prompt]				,generator=lowerCamelCase_				,prior_num_inference_steps=2				,decoder_num_inference_steps=2				,super_res_num_inference_steps=2				,prior_latents=lowerCamelCase_				,decoder_latents=lowerCamelCase_				,super_res_latents=lowerCamelCase_				,output_type="np"				,)
          _UpperCAmelCase 						=       output.images

          _UpperCAmelCase 						=       tokenizer(
              lowerCamelCase_				,padding="max_length"				,max_length=tokenizer.model_max_length				,return_tensors="pt"				,)
          _UpperCAmelCase 						=       text_encoder(text_inputs.input_ids		)
          _UpperCAmelCase 						=       text_inputs.attention_mask

          _UpperCAmelCase 						=       torch.Generator(device=lowerCamelCase_		).manual_seed(0		)
          _UpperCAmelCase 						=       pipe(
              generator=lowerCamelCase_				,prior_num_inference_steps=2				,decoder_num_inference_steps=2				,super_res_num_inference_steps=2				,prior_latents=lowerCamelCase_				,decoder_latents=lowerCamelCase_				,super_res_latents=lowerCamelCase_				,text_model_output=lowerCamelCase_				,text_attention_mask=lowerCamelCase_				,output_type="np"				,)[0]

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







       @skip_mps
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       torch_device == "cpu"

          self._test_attention_slicing_forward_pass(test_max_difference=lowerCamelCase_				,expected_max_diff=0.0_1		)







       @skip_mps
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       torch_device == "cpu"
          _UpperCAmelCase 						=       True
          _UpperCAmelCase 						=       [
              "prior_num_inference_steps",
              "decoder_num_inference_steps",
              "super_res_num_inference_steps",
          ]

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







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       [
              "prior_num_inference_steps",
              "decoder_num_inference_steps",
              "super_res_num_inference_steps",
          ]

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







       @skip_mps
       def  _snake_case      (       self		):



          '''simple docstring'''

          return super().test_dict_tuple_outputs_equivalent()







       @skip_mps
       def  _snake_case      (       self		):



          '''simple docstring'''

          return super().test_save_load_local()







       @skip_mps
       def  _snake_case      (       self		):



          '''simple docstring'''

          return super().test_save_load_optional_components()






@nightly
class      __a      (       unittest.TestCase      ):







       def  _snake_case      (       self		):



          '''simple docstring'''

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







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/unclip/karlo_v1_alpha_horse_cpu.npy"		)

          _UpperCAmelCase 						=       UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"		)
          pipeline.set_progress_bar_config(disable=lowerCamelCase_		)

          _UpperCAmelCase 						=       torch.manual_seed(0		)
          _UpperCAmelCase 						=       pipeline(
              "horse"				,num_images_per_prompt=1				,generator=lowerCamelCase_				,output_type="np"				,)

          _UpperCAmelCase 						=       output.images[0]

          assert image.shape == (256, 256, 3)
          assert np.abs(expected_image - image		).max() < 1e-1






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







       def  _snake_case      (       self		):



          '''simple docstring'''

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







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/unclip/karlo_v1_alpha_horse_fp16.npy"		)

          _UpperCAmelCase 						=       UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"				,torch_dtype=torch.floataa		)
          _UpperCAmelCase 						=       pipeline.to(lowerCamelCase_		)
          pipeline.set_progress_bar_config(disable=lowerCamelCase_		)

          _UpperCAmelCase 						=       torch.Generator(device="cpu"		).manual_seed(0		)
          _UpperCAmelCase 						=       pipeline(
              "horse"				,generator=lowerCamelCase_				,output_type="np"				,)

          _UpperCAmelCase 						=       output.images[0]

          assert image.shape == (256, 256, 3)

          assert_mean_pixel_difference(lowerCamelCase_				,lowerCamelCase_		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          torch.cuda.empty_cache()
          torch.cuda.reset_max_memory_allocated()
          torch.cuda.reset_peak_memory_stats()

          _UpperCAmelCase 						=       UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"				,torch_dtype=torch.floataa		)
          _UpperCAmelCase 						=       pipe.to(lowerCamelCase_		)
          pipe.set_progress_bar_config(disable=lowerCamelCase_		)
          pipe.enable_attention_slicing()
          pipe.enable_sequential_cpu_offload()

          _UpperCAmelCase 						=       pipe(
              "horse"				,num_images_per_prompt=1				,prior_num_inference_steps=2				,decoder_num_inference_steps=2				,super_res_num_inference_steps=2				,output_type="np"				,)

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

