




'''simple docstring'''


from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


_snake_case				:				List[str]       							=		logging.get_logger(__name__)  # pylint: disable=invalid-name

_snake_case				:				Optional[int]       							=		'\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")\n        >>> pipe_prior.to("cuda")\n        >>> prompt = "red cat, 4k photo"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> zero_image_emb = out.negative_image_embeds\n        >>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")\n        >>> pipe.to("cuda")\n        >>> image = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=50,\n        ... ).images\n        >>> image[0].save("cat.png")\n        ```\n'
def 		snake_case_   (UpperCamelCase	:  Optional[Any]			,						UpperCamelCase	:  Dict			,						UpperCamelCase	:  str=8				):





       '''simple docstring'''


       _a     					=    height // scale_factor**2
       if height % scale_factor**2 != 0:
              new_height += 1
       _a     					=    width // scale_factor**2
       if width % scale_factor**2 != 0:
              new_width += 1
       return new_height * scale_factor, new_width * scale_factor

class       A   (		lowerCamelCase__   ):







       def __init__(  self	:  Dict							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[Any]							,      )      ->							int:


              """simple docstring"""


              super().__init__()

              self.register_modules(
                  unet=__lowerCamelCase							,      scheduler=__lowerCamelCase							,      movq=__lowerCamelCase							,      )
              _a     					=    2 ** (len(self.movq.config.block_out_channels ) - 1)







       def        __lowerCAmelCase      (  self	:  int							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[int]							,      lowerCAmelCase_	:  Tuple )      ->							Tuple:


              """simple docstring"""


              if latents is None:
                     _a     					=    randn_tensor(__lowerCamelCase							,      generator=__lowerCamelCase							,      device=__lowerCamelCase							,      dtype=__lowerCamelCase )
              else:
                     if latents.shape != shape:
                            raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {shape}' )
                     _a     					=    latents.to(__lowerCamelCase )

              _a     					=    latents * scheduler.init_noise_sigma
              return latents







       def        __lowerCAmelCase      (  self	:  int							,      lowerCAmelCase_	:  List[Any]=0 )      ->							Dict:


              """simple docstring"""


              if is_accelerate_available():
                     from accelerate import cpu_offload
              else:
                     raise ImportError('''Please install accelerate via `pip install accelerate`''' )

              _a     					=    torch.device(F'cuda:{gpu_id}' )

              _a     					=    [
                  self.unet,
                  self.movq,
              ]
              for cpu_offloaded_model in models:
                     if cpu_offloaded_model is not None:
                            cpu_offload(__lowerCamelCase							,      __lowerCamelCase )







       def        __lowerCAmelCase      (  self	:  Tuple							,      lowerCAmelCase_	:  str=0 )      ->							Union[str, Any]:


              """simple docstring"""


              if is_accelerate_available() and is_accelerate_version('''>='''							,      '''0.17.0.dev0''' ):
                     from accelerate import cpu_offload_with_hook
              else:
                     raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.''' )

              _a     					=    torch.device(F'cuda:{gpu_id}' )

              if self.device.type != "cpu":
                     self.to('''cpu'''							,      silence_dtype_warnings=__lowerCamelCase )
                     torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

              _a     					=    None
              for cpu_offloaded_model in [self.unet, self.movq]:
                     _a     					=    cpu_offload_with_hook(__lowerCamelCase							,      __lowerCamelCase							,      prev_module_hook=__lowerCamelCase )

              # We'll offload the last model manually.
              _a     					=    hook







       @property
       # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
       def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Dict:


              """simple docstring"""


              if not hasattr(self.unet							,      '''_hf_hook''' ):
                     return self.device
              for module in self.unet.modules():
                     if (
                         hasattr(__lowerCamelCase							,      '''_hf_hook''' )
                         and hasattr(module._hf_hook							,      '''execution_device''' )
                         and module._hf_hook.execution_device is not None
                     ):
                            return torch.device(module._hf_hook.execution_device )
              return self.device







       @torch.no_grad()
       @replace_example_docstring(__lowerCamelCase )
       def __call__(  self	:  Optional[int]							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[int] = 5_12							,      lowerCAmelCase_	:  int = 5_12							,      lowerCAmelCase_	:  Union[str, Any] = 1_00							,      lowerCAmelCase_	:  int = 4.0							,      lowerCAmelCase_	:  int = 1							,      lowerCAmelCase_	:  Union[str, Any] = None							,      lowerCAmelCase_	:  Optional[int] = None							,      lowerCAmelCase_	:  List[str] = "pil"							,      lowerCAmelCase_	:  Tuple = True							,      )      ->							Union[str, Any]:


              """simple docstring"""


              _a     					=    self._execution_device

              _a     					=    guidance_scale > 1.0

              if isinstance(__lowerCamelCase							,      __lowerCamelCase ):
                     _a     					=    torch.cat(__lowerCamelCase							,      dim=0 )
              _a     					=    image_embeds.shape[0] * num_images_per_prompt
              if isinstance(__lowerCamelCase							,      __lowerCamelCase ):
                     _a     					=    torch.cat(__lowerCamelCase							,      dim=0 )

              if do_classifier_free_guidance:
                     _a     					=    image_embeds.repeat_interleave(__lowerCamelCase							,      dim=0 )
                     _a     					=    negative_image_embeds.repeat_interleave(__lowerCamelCase							,      dim=0 )

              _a     					=    torch.cat([negative_image_embeds, image_embeds]							,      dim=0 ).to(dtype=self.unet.dtype							,      device=__lowerCamelCase )

              self.scheduler.set_timesteps(__lowerCamelCase							,      device=__lowerCamelCase )
              _a     					=    self.scheduler.timesteps

              _a     					=    self.unet.config.in_channels

              _a     					=    downscale_height_and_width(__lowerCamelCase							,      __lowerCamelCase							,      self.movq_scale_factor )

              # create initial latent
              _a     					=    self.prepare_latents(
                  (batch_size, num_channels_latents, height, width)							,      image_embeds.dtype							,      __lowerCamelCase							,      __lowerCamelCase							,      __lowerCamelCase							,      self.scheduler							,      )

              for i, t in enumerate(self.progress_bar(__lowerCamelCase ) ):
                     # expand the latents if we are doing classifier free guidance
                     _a     					=    torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents

                     _a     					=    {'''image_embeds''': image_embeds}
                     _a     					=    self.unet(
                         sample=__lowerCamelCase							,      timestep=__lowerCamelCase							,      encoder_hidden_states=__lowerCamelCase							,      added_cond_kwargs=__lowerCamelCase							,      return_dict=__lowerCamelCase							,      )[0]

                     if do_classifier_free_guidance:
                            _a     					=    noise_pred.split(latents.shape[1]							,      dim=1 )
                            _a     					=    noise_pred.chunk(2 )
                            _a     					=    variance_pred.chunk(2 )
                            _a     					=    noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
                            _a     					=    torch.cat([noise_pred, variance_pred_text]							,      dim=1 )

                     if not (
                         hasattr(self.scheduler.config							,      '''variance_type''' )
                         and self.scheduler.config.variance_type in ["learned", "learned_range"]
                     ):
                            _a     					=    noise_pred.split(latents.shape[1]							,      dim=1 )

                     # compute the previous noisy sample x_t -> x_t-1
                     _a     					=    self.scheduler.step(
                         __lowerCamelCase							,      __lowerCamelCase							,      __lowerCamelCase							,      generator=__lowerCamelCase							,      )[0]
              # post-processing
              _a     					=    self.movq.decode(__lowerCamelCase							,      force_not_quantize=__lowerCamelCase )['''sample''']

              if output_type not in ["pt", "np", "pil"]:
                     raise ValueError(F'Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}' )

              if output_type in ["np", "pil"]:
                     _a     					=    image * 0.5 + 0.5
                     _a     					=    image.clamp(0							,      1 )
                     _a     					=    image.cpu().permute(0							,      2							,      3							,      1 ).float().numpy()

              if output_type == "pil":
                     _a     					=    self.numpy_to_pil(__lowerCamelCase )

              if not return_dict:
                     return (image,)

              return ImagePipelineOutput(images=__lowerCamelCase )







'''simple docstring'''


def 		snake_case_   (UpperCamelCase	:  str			,						UpperCamelCase	:  Any				):





							'''simple docstring'''


							return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2
def 		snake_case_   (UpperCamelCase	:  Any			,						UpperCamelCase	:  str=0				):





							'''simple docstring'''


							return sorted(UpperCamelCase			,						key=lambda UpperCamelCase				: x[column]				)
def 		snake_case_   (UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  Any			,						UpperCamelCase	:  Union[str, Any]=float('''inf'''				)				):





							'''simple docstring'''


							for i in range(points_counts - 1				):
														for j in range(i + 1			,						UpperCamelCase				):
																					_a     					=    euclidean_distance_sqr(points[i]			,						points[j]				)
																					if current_dis < min_dis:
																												_a     					=    current_dis
							return min_dis
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  Tuple			,						UpperCamelCase	:  List[str]=float('''inf'''				)				):





							'''simple docstring'''


							for i in range(min(6			,						points_counts - 1				)			,						UpperCamelCase				):
														for j in range(max(0			,						i - 6				)			,						UpperCamelCase				):
																					_a     					=    euclidean_distance_sqr(points[i]			,						points[j]				)
																					if current_dis < min_dis:
																												_a     					=    current_dis
							return min_dis
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  List[Any]			,						UpperCamelCase	:  int				):





							'''simple docstring'''


							if points_counts <= 3:
														return dis_between_closest_pair(UpperCamelCase			,						UpperCamelCase				)

							# recursion
							_a     					=    points_counts // 2
							_a     					=    closest_pair_of_points_sqr(
							    UpperCamelCase			,						points_sorted_on_y[:mid]			,						UpperCamelCase				)
							_a     					=    closest_pair_of_points_sqr(
							    UpperCamelCase			,						points_sorted_on_y[mid:]			,						points_counts - mid				)
							_a     					=    min(UpperCamelCase			,						UpperCamelCase				)
							_a     					=    []
							for point in points_sorted_on_x:
														if abs(point[0] - points_sorted_on_x[mid][0]				) < closest_pair_dis:
																					cross_strip.append(UpperCamelCase				)

							_a     					=    dis_between_closest_in_strip(
							    UpperCamelCase			,						len(UpperCamelCase				)			,						UpperCamelCase				)
							return min(UpperCamelCase			,						UpperCamelCase				)
def 		snake_case_   (UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  List[str]				):





							'''simple docstring'''


							_a     					=    column_based_sort(UpperCamelCase			,						column=0				)
							_a     					=    column_based_sort(UpperCamelCase			,						column=1				)
							return (
							    closest_pair_of_points_sqr(
							        UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase				)
							) ** 0.5


if __name__ == "__main__":
				_snake_case				:				int       							=		[(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
				print('Distance:', closest_pair_of_points(points, len(points)))

