code: 
  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  lowerCAmelCase__   (       lowercase__       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    _UpperCamelCase						= CONFIG_NAME
  
    @register_to_config
    def __init__(self  : Union[str, Any]	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : int = 8	, lowerCAmelCase_  : str = "lanczos"	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : bool = False	, )   ->       int:
          super().__init__()
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : np.ndarray    )   ->       PIL.Image.Image:
          if images.ndim == 3:
                snake_case_						       =							images[None, ...]
          snake_case_						       =							(images * 2_55).round().astype("uint8"    )
          if images.shape[-1] == 1:
                # special case for grayscale (single channel) images
                snake_case_						       =							[Image.fromarray(image.squeeze()	, mode="L"    ) for image in images]
          else:
                snake_case_						       =							[Image.fromarray(_A    ) for image in images]
  
          return pil_images
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : Union[List[PIL.Image.Image], PIL.Image.Image]    )   ->       np.ndarray:
          if not isinstance(_A	, _A    ):
                snake_case_						       =							[images]
          snake_case_						       =							[np.array(_A    ).astype(np.floataa    ) / 255.0 for image in images]
          snake_case_						       =							np.stack(_A	, axis=0    )
  
          return images
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : np.ndarray    )   ->       torch.FloatTensor:
          if images.ndim == 3:
                snake_case_						       =							images[..., None]
  
          snake_case_						       =							torch.from_numpy(images.transpose(0	, 3	, 1	, 2    )    )
          return images
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : torch.FloatTensor    )   ->       np.ndarray:
          snake_case_						       =							images.cpu().permute(0	, 2	, 3	, 1    ).float().numpy()
          return images
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : str    )   ->       Union[str, Any]:
          return 2.0 * images - 1.0
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : Any    )   ->       Union[str, Any]:
          return (images / 2 + 0.5).clamp(0	, 1    )
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : PIL.Image.Image    )   ->       PIL.Image.Image:
          snake_case_						       =							image.convert("RGB"    )
          return image
  
    def 		_lowerCamelCase	(self  : List[Any]	, lowerCAmelCase_  : PIL.Image.Image	, lowerCAmelCase_  : Optional[int] = None	, lowerCAmelCase_  : Optional[int] = None	, )   ->       PIL.Image.Image:
          if height is None:
                snake_case_						       =							image.height
          if width is None:
                snake_case_						       =							image.width
  
          snake_case_						       =							(
              x - x % self.config.vae_scale_factor for x in (width, height)
          )  # resize to integer multiple of vae_scale_factor
          snake_case_						       =							image.resize((width, height)	, resample=PIL_INTERPOLATION[self.config.resample]    )
          return image
  
    def 		_lowerCamelCase	(self  : Optional[Any]	, lowerCAmelCase_  : Union[torch.FloatTensor, PIL.Image.Image, np.ndarray]	, lowerCAmelCase_  : Optional[int] = None	, lowerCAmelCase_  : Optional[int] = None	, )   ->       torch.Tensor:
          snake_case_						       =							(PIL.Image.Image, np.ndarray, torch.Tensor)
          if isinstance(_A	, _A    ):
                snake_case_						       =							[image]
          elif not (isinstance(_A	, _A    ) and all(isinstance(_A	, _A    ) for i in image    )):
                raise ValueError(
                    f'''Input is in incorrect format: {[type(_A    ) for i in image]}. Currently, we only support {', '.join(_A    )}'''    )
  
          if isinstance(image[0]	, PIL.Image.Image    ):
                if self.config.do_convert_rgb:
                      snake_case_						       =							[self.convert_to_rgb(_A    ) for i in image]
                if self.config.do_resize:
                      snake_case_						       =							[self.resize(_A	, _A	, _A    ) for i in image]
                snake_case_						       =							self.pil_to_numpy(_A    )  # to np
                snake_case_						       =							self.numpy_to_pt(_A    )  # to pt
  
          elif isinstance(image[0]	, np.ndarray    ):
                snake_case_						       =							np.concatenate(_A	, axis=0    ) if image[0].ndim == 4 else np.stack(_A	, axis=0    )
                snake_case_						       =							self.numpy_to_pt(_A    )
                snake_case_						       =							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    ):
                snake_case_						       =							torch.cat(_A	, axis=0    ) if image[0].ndim == 4 else torch.stack(_A	, axis=0    )
                snake_case_						       =							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]
          snake_case_						       =							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()}]'''	, _A	, )
                snake_case_						       =							False
  
          if do_normalize:
                snake_case_						       =							self.normalize(_A    )
  
          return image
  
  
    def 		_lowerCamelCase	(self  : Union[str, Any]	, lowerCAmelCase_  : torch.FloatTensor	, lowerCAmelCase_  : str = "pil"	, lowerCAmelCase_  : Optional[List[bool]] = None	, )   ->       Optional[Any]:
          if not isinstance(_A	, torch.Tensor    ):
                raise ValueError(
                    f'''Input for postprocessing is in incorrect format: {type(_A    )}. We only support pytorch tensor'''    )
          if output_type not in ["latent", "pt", "np", "pil"]:
                snake_case_						       =							(
                    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"	, _A	, standard_warn=_A    )
                snake_case_						       =							'np'
  
          if output_type == "latent":
                return image
  
          if do_denormalize is None:
                snake_case_						       =							[self.config.do_normalize] * image.shape[0]
  
          snake_case_						       =							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
  
          snake_case_						       =							self.pt_to_numpy(_A    )
  
          if output_type == "np":
                return image
  
          if output_type == "pil":
                return self.numpy_to_pil(_A    )
  
  
  
  class  lowerCAmelCase__   (       lowercase__       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    _UpperCamelCase						= CONFIG_NAME
  
    @register_to_config
    def __init__(self  : List[str]	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : int = 8	, lowerCAmelCase_  : str = "lanczos"	, lowerCAmelCase_  : bool = True	, )   ->       Tuple:
          super().__init__()
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : Union[str, Any]    )   ->       Optional[int]:
          if images.ndim == 3:
                snake_case_						       =							images[None, ...]
          snake_case_						       =							(images * 2_55).round().astype("uint8"    )
          if images.shape[-1] == 1:
                # special case for grayscale (single channel) images
                snake_case_						       =							[Image.fromarray(image.squeeze()	, mode="L"    ) for image in images]
          else:
                snake_case_						       =							[Image.fromarray(image[:, :, :3]    ) for image in images]
  
          return pil_images
  
    @staticmethod
    def 		_lowerCamelCase	(lowerCAmelCase_  : Optional[int]    )   ->       Optional[Any]:
          return image[:, :, 1] * 2**8 + image[:, :, 2]
  
    def 		_lowerCamelCase	(self  : Union[str, Any]	, lowerCAmelCase_  : Dict    )   ->       Dict:
          if images.ndim == 3:
                snake_case_						       =							images[None, ...]
          snake_case_						       =							images[:, :, :, 3:]
          if images.shape[-1] == 6:
                snake_case_						       =							(images_depth * 2_55).round().astype("uint8"    )
                snake_case_						       =							[
                    Image.fromarray(self.rgblike_to_depthmap(_A    )	, mode="I;16"    ) for image_depth in images_depth
                ]
          elif images.shape[-1] == 4:
                snake_case_						       =							(images_depth * 6_55_35.0).astype(np.uintaa    )
                snake_case_						       =							[Image.fromarray(_A	, mode="I;16"    ) for image_depth in images_depth]
          else:
                raise Exception("Not supported"    )
  
          return pil_images
  
  
    def 		_lowerCamelCase	(self  : List[str]	, lowerCAmelCase_  : torch.FloatTensor	, lowerCAmelCase_  : str = "pil"	, lowerCAmelCase_  : Optional[List[bool]] = None	, )   ->       int:
          if not isinstance(_A	, torch.Tensor    ):
                raise ValueError(
                    f'''Input for postprocessing is in incorrect format: {type(_A    )}. We only support pytorch tensor'''    )
          if output_type not in ["latent", "pt", "np", "pil"]:
                snake_case_						       =							(
                    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"	, _A	, standard_warn=_A    )
                snake_case_						       =							'np'
  
          if do_denormalize is None:
                snake_case_						       =							[self.config.do_normalize] * image.shape[0]
  
          snake_case_						       =							torch.stack(
              [self.denormalize(image[i]    ) if do_denormalize[i] else image[i] for i in range(image.shape[0]    )]    )
  
          snake_case_						       =							self.pt_to_numpy(_A    )
  
          if output_type == "np":
                if image.shape[-1] == 6:
                      snake_case_						       =							np.stack([self.rgblike_to_depthmap(im[:, :, 3:]    ) for im in image]	, axis=0    )
                else:
                      snake_case_						       =							image[:, :, :, 3:]
                return image[:, :, :, :3], image_depth
  
          if output_type == "pil":
                return self.numpy_to_pil(_A    ), self.numpy_to_depth(_A    )
          else:
                raise Exception(f'''This type {output_type} is not supported'''    )
  
  
style_context: 
  '''simple docstring'''
  
  
  
  
  
  def   snake_case_       (							_a     :							int = 1_000			):
        return sum(i for i in range(_a			) if i % 3 == 0 or i % 5 == 0			)
  
  
  if __name__ == "__main__":
       print(F"""{solution() = }""")
  
  