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