






"""simple docstring"""



import warnings
from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from .configuration_utils import ConfigMixin, register_to_config
from .utils import CONFIG_NAME, PIL_INTERPOLATION, deprecate






class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase		):
							snake_case_  =				CONFIG_NAME


							@register_to_config
							def __init__(      self   :    Union[str, Any]      ,     snake_case   :    str = True      ,     snake_case   :    List[Any] = 8      ,     snake_case   :    Any = "lanczos"      ,     snake_case   :    Optional[int] = True      ,     snake_case   :    List[str] = False      ,     ):
													'''simple docstring'''





													super().__init__()


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    str				):
													'''simple docstring'''





													if images.ndim == 3:
																			A__    :	Dict			=	images[None, ...]
													A__    :	List[Any]			=	(images * 255).round().astype("""uint8"""				)
													if images.shape[-1] == 1:
																			# special case for grayscale (single channel) images
																			A__    :	Optional[Any]			=	[Image.fromarray(image.squeeze()      ,     mode="""L"""				) for image in images]
													else:
																			A__    :	Union[str, Any]			=	[Image.fromarray(snake_case				) for image in images]

													return pil_images


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    Tuple				):
													'''simple docstring'''





													if not isinstance(snake_case      ,     snake_case				):
																			A__    :	str			=	[images]
													A__    :	int			=	[np.array(snake_case				).astype(np.floataa				) / 255.0 for image in images]
													A__    :	Dict			=	np.stack(snake_case      ,     axis=0				)

													return images


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    Optional[int]				):
													'''simple docstring'''





													if images.ndim == 3:
																			A__    :	Optional[int]			=	images[..., None]

													A__    :	List[str]			=	torch.from_numpy(images.transpose(0      ,     3      ,     1      ,     2				)				)
													return images


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    Union[str, Any]				):
													'''simple docstring'''





													A__    :	Any			=	images.cpu().permute(0      ,     2      ,     3      ,     1				).float().numpy()
													return images


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    Union[str, Any]				):
													'''simple docstring'''





													return 2.0 * images - 1.0


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    Tuple				):
													'''simple docstring'''





													return (images / 2 + 0.5).clamp(0      ,     1				)


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    List[Any]				):
													'''simple docstring'''





													A__    :	Dict			=	image.convert("""RGB"""				)
													return image


							def     _UpperCamelCase							(      self   :    int      ,     snake_case   :    List[Any]      ,     snake_case   :    Any = None      ,     snake_case   :    List[Any] = None      ,     ):
													'''simple docstring'''





													if height is None:
																			A__    :	Union[str, Any]			=	image.height
													if width is None:
																			A__    :	Optional[Any]			=	image.width

													A__    :	Optional[int]			=	(
													    x - x % self.config.vae_scale_factor for x in (width, height)
													)  # resize to integer multiple of vae_scale_factor
													A__    :	Any			=	image.resize((width, height)      ,     resample=PIL_INTERPOLATION[self.config.resample]				)
													return image


							def     _UpperCamelCase							(      self   :    Optional[int]      ,     snake_case   :    Dict      ,     snake_case   :    Optional[Any] = None      ,     snake_case   :    List[Any] = None      ,     ):
													'''simple docstring'''





													A__    :	List[Any]			=	(PIL.Image.Image, np.ndarray, torch.Tensor)
													if isinstance(snake_case      ,     snake_case				):
																			A__    :	List[Any]			=	[image]
													elif not (isinstance(snake_case      ,     snake_case				) and all(isinstance(snake_case      ,     snake_case				) for i in image				)):
																			raise ValueError(
																			    F'Input is in incorrect format: {[type(snake_case				) for i in image]}. Currently, we only support {", ".join(snake_case				)}'				)

													if isinstance(image[0]      ,     PIL.Image.Image				):
																			if self.config.do_convert_rgb:
																									A__    :	List[Any]			=	[self.convert_to_rgb(snake_case				) for i in image]
																			if self.config.do_resize:
																									A__    :	Union[str, Any]			=	[self.resize(snake_case      ,     snake_case      ,     snake_case				) for i in image]
																			A__    :	Union[str, Any]			=	self.pil_to_numpy(snake_case				)  # to np
																			A__    :	int			=	self.numpy_to_pt(snake_case				)  # to pt

													elif isinstance(image[0]      ,     np.ndarray				):
																			A__    :	str			=	np.concatenate(snake_case      ,     axis=0				) if image[0].ndim == 4 else np.stack(snake_case      ,     axis=0				)
																			A__    :	Dict			=	self.numpy_to_pt(snake_case				)
																			A__    :	Tuple			=	image.shape
																			if self.config.do_resize and (
																			    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
																			):
																									raise ValueError(
																									    F'Currently we only support resizing for PIL image - please resize your numpy array to be divisible by {self.config.vae_scale_factor}'
																									    F'currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'				)

													elif isinstance(image[0]      ,     torch.Tensor				):
																			A__    :	int			=	torch.cat(snake_case      ,     axis=0				) if image[0].ndim == 4 else torch.stack(snake_case      ,     axis=0				)
																			A__    :	Dict			=	image.shape

																			# don't need any preprocess if the image is latents
																			if channel == 4:
																									return image

																			if self.config.do_resize and (
																			    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
																			):
																									raise ValueError(
																									    F'Currently we only support resizing for PIL image - please resize your pytorch tensor to be divisible by {self.config.vae_scale_factor}'
																									    F'currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'				)

        # expected range [0,1], normalize to [-1,1]
													A__    :	Optional[int]			=	self.config.do_normalize
													if image.min() < 0:
																			warnings.warn(
																			    """Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] """
																			    F'when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]'      ,     snake_case      ,     )
																			A__    :	Dict			=	False

													if do_normalize:
																			A__    :	Tuple			=	self.normalize(snake_case				)

													return image


							def     _UpperCamelCase							(      self   :    Any      ,     snake_case   :    int      ,     snake_case   :    Optional[int] = "pil"      ,     snake_case   :    Union[str, Any] = None      ,     ):
													'''simple docstring'''





													if not isinstance(snake_case      ,     torch.Tensor				):
																			raise ValueError(
																			    F'Input for postprocessing is in incorrect format: {type(snake_case				)}. We only support pytorch tensor'				)
													if output_type not in ["latent", "pt", "np", "pil"]:
																			A__    :	List[Any]			=	(
																			    F'the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '
																			    '`pil`, `np`, `pt`, `latent`'
																			)
																			deprecate("""Unsupported output_type"""      ,     """1.0.0"""      ,     snake_case      ,     standard_warn=snake_case				)
																			A__    :	Any			=	'np'

													if output_type == "latent":
																			return image

													if do_denormalize is None:
																			A__    :	List[str]			=	[self.config.do_normalize] * image.shape[0]

													A__    :	Union[str, Any]			=	torch.stack(
													    [self.denormalize(image[i]				) if do_denormalize[i] else image[i] for i in range(image.shape[0]				)]				)

													if output_type == "pt":
																			return image

													A__    :	int			=	self.pt_to_numpy(snake_case				)

													if output_type == "np":
																			return image

													if output_type == "pil":
																			return self.numpy_to_pil(snake_case				)






class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase		):
							snake_case_  =				CONFIG_NAME


							@register_to_config
							def __init__(      self   :    Optional[Any]      ,     snake_case   :    Union[str, Any] = True      ,     snake_case   :    Optional[int] = 8      ,     snake_case   :    str = "lanczos"      ,     snake_case   :    int = True      ,     ):
													'''simple docstring'''





													super().__init__()


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    List[Any]				):
													'''simple docstring'''





													if images.ndim == 3:
																			A__    :	Tuple			=	images[None, ...]
													A__    :	int			=	(images * 255).round().astype("""uint8"""				)
													if images.shape[-1] == 1:
																			# special case for grayscale (single channel) images
																			A__    :	Tuple			=	[Image.fromarray(image.squeeze()      ,     mode="""L"""				) for image in images]
													else:
																			A__    :	int			=	[Image.fromarray(image[:, :, :3]				) for image in images]

													return pil_images


							@staticmethod
							def     _UpperCamelCase							(      snake_case   :    List[Any]				):
													'''simple docstring'''





													return image[:, :, 1] * 2**8 + image[:, :, 2]


							def     _UpperCamelCase							(      self   :    int      ,     snake_case   :    str				):
													'''simple docstring'''





													if images.ndim == 3:
																			A__    :	Any			=	images[None, ...]
													A__    :	Any			=	images[:, :, :, 3:]
													if images.shape[-1] == 6:
																			A__    :	Tuple			=	(images_depth * 255).round().astype("""uint8"""				)
																			A__    :	str			=	[
																			    Image.fromarray(self.rgblike_to_depthmap(snake_case				)      ,     mode="""I;16"""				) for image_depth in images_depth
																			]
													elif images.shape[-1] == 4:
																			A__    :	Optional[int]			=	(images_depth * 6_5535.0).astype(np.uintaa				)
																			A__    :	Any			=	[Image.fromarray(snake_case      ,     mode="""I;16"""				) for image_depth in images_depth]
													else:
																			raise Exception("""Not supported"""				)

													return pil_images


							def     _UpperCamelCase							(      self   :    str      ,     snake_case   :    Tuple      ,     snake_case   :    Any = "pil"      ,     snake_case   :    Optional[int] = None      ,     ):
													'''simple docstring'''





													if not isinstance(snake_case      ,     torch.Tensor				):
																			raise ValueError(
																			    F'Input for postprocessing is in incorrect format: {type(snake_case				)}. We only support pytorch tensor'				)
													if output_type not in ["latent", "pt", "np", "pil"]:
																			A__    :	List[Any]			=	(
																			    F'the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '
																			    '`pil`, `np`, `pt`, `latent`'
																			)
																			deprecate("""Unsupported output_type"""      ,     """1.0.0"""      ,     snake_case      ,     standard_warn=snake_case				)
																			A__    :	Tuple			=	'np'

													if do_denormalize is None:
																			A__    :	List[str]			=	[self.config.do_normalize] * image.shape[0]

													A__    :	Union[str, Any]			=	torch.stack(
													    [self.denormalize(image[i]				) if do_denormalize[i] else image[i] for i in range(image.shape[0]				)]				)

													A__    :	Optional[int]			=	self.pt_to_numpy(snake_case				)

													if output_type == "np":
																			if image.shape[-1] == 6:
																									A__    :	int			=	np.stack([self.rgblike_to_depthmap(im[:, :, 3:]				) for im in image]      ,     axis=0				)
																			else:
																									A__    :	Optional[Any]			=	image[:, :, :, 3:]
																			return image[:, :, :, :3], image_depth

													if output_type == "pil":
																			return self.numpy_to_pil(snake_case				), self.numpy_to_depth(snake_case				)
													else:
																			raise Exception(F'This type {output_type} is not supported'				)













'''simple docstring'''


from __future__ import annotations




def       A							(      _UpperCAmelCase   :				list					)  ->				int | float:


  '''simple docstring'''




  __lowerCAmelCase		:    List[Any]			     =  sorted(_UpperCAmelCase					)
  __lowerCAmelCase		:    List[str]			     =  len(_UpperCAmelCase					)
  __lowerCAmelCase		:    Any			     =  length >> 1
  return (
      (sorted_list[mid_index] + sorted_list[mid_index - 1]) / 2
      if length % 2 == 0
      else sorted_list[mid_index]
  )




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


  '''simple docstring'''




  import doctest

  doctest.testmod()


if __name__ == "__main__":
    main()





