




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_   ( A							):




							'''simple docstring'''



							a__    	=  CONFIG_NAME





							@register_to_config
							def __init__(       self							:						str							,  a							:						bool = True							,  a							:						int = 8							,  a							:						str = "lanczos"							,  a							:						bool = True							,  a							:						bool = False							,  )      ->       Union[str, Any]:
										super().__init__()





							@staticmethod
							def  _UpperCAmelCase  (       a							:						np.ndarray      )      ->       PIL.Image.Image:
										if images.ndim == 3:
													SCREAMING_SNAKE_CASE     =       images[None, ...]
										SCREAMING_SNAKE_CASE     =       (images * 255).round().astype("""uint8"""      )
										if images.shape[-1] == 1:
													# special case for grayscale (single channel) images
													SCREAMING_SNAKE_CASE     =       [Image.fromarray(image.squeeze()							,  mode="""L"""      ) for image in images]
										else:
													SCREAMING_SNAKE_CASE     =       [Image.fromarray(a      ) for image in images]

										return pil_images





							@staticmethod
							def  _UpperCAmelCase  (       a							:						Union[List[PIL.Image.Image], PIL.Image.Image]      )      ->       np.ndarray:
										if not isinstance(a							,  a      ):
													SCREAMING_SNAKE_CASE     =       [images]
										SCREAMING_SNAKE_CASE     =       [np.array(a      ).astype(np.floataa      ) / 255.0 for image in images]
										SCREAMING_SNAKE_CASE     =       np.stack(a							,  axis=0      )

										return images





							@staticmethod
							def  _UpperCAmelCase  (       a							:						np.ndarray      )      ->       torch.FloatTensor:
										if images.ndim == 3:
													SCREAMING_SNAKE_CASE     =       images[..., None]

										SCREAMING_SNAKE_CASE     =       torch.from_numpy(images.transpose(0							,  3							,  1							,  2      )      )
										return images





							@staticmethod
							def  _UpperCAmelCase  (       a							:						torch.FloatTensor      )      ->       np.ndarray:
										SCREAMING_SNAKE_CASE     =       images.cpu().permute(0							,  2							,  3							,  1      ).float().numpy()
										return images





							@staticmethod
							def  _UpperCAmelCase  (       a							:						int      )      ->       Tuple:
										return 2.0 * images - 1.0





							@staticmethod
							def  _UpperCAmelCase  (       a							:						Union[str, Any]      )      ->       Optional[int]:
										return (images / 2 + 0.5).clamp(0							,  1      )





							@staticmethod
							def  _UpperCAmelCase  (       a							:						PIL.Image.Image      )      ->       PIL.Image.Image:
										SCREAMING_SNAKE_CASE     =       image.convert("""RGB"""      )
										return image





							def  _UpperCAmelCase  (       self							:						List[Any]							,  a							:						PIL.Image.Image							,  a							:						Optional[int] = None							,  a							:						Optional[int] = None							,  )      ->       PIL.Image.Image:
										if height is None:
													SCREAMING_SNAKE_CASE     =       image.height
										if width is None:
													SCREAMING_SNAKE_CASE     =       image.width

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





							def  _UpperCAmelCase  (       self							:						Union[str, Any]							,  a							:						Union[torch.FloatTensor, PIL.Image.Image, np.ndarray]							,  a							:						Optional[int] = None							,  a							:						Optional[int] = None							,  )      ->       torch.Tensor:
										SCREAMING_SNAKE_CASE     =       (PIL.Image.Image, np.ndarray, torch.Tensor)
										if isinstance(a							,  a      ):
													SCREAMING_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:
																SCREAMING_SNAKE_CASE     =       [self.convert_to_rgb(a      ) for i in image]
													if self.config.do_resize:
																SCREAMING_SNAKE_CASE     =       [self.resize(a							,  a							,  a      ) for i in image]
													SCREAMING_SNAKE_CASE     =       self.pil_to_numpy(a      )  # to np
													SCREAMING_SNAKE_CASE     =       self.numpy_to_pt(a      )  # to pt

										elif isinstance(image[0]							,  np.ndarray      ):
													SCREAMING_SNAKE_CASE     =       np.concatenate(a							,  axis=0      ) if image[0].ndim == 4 else np.stack(a							,  axis=0      )
													SCREAMING_SNAKE_CASE     =       self.numpy_to_pt(a      )
													SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	SCREAMING_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      ):
													SCREAMING_SNAKE_CASE     =       torch.cat(a							,  axis=0      ) if image[0].ndim == 4 else torch.stack(a							,  axis=0      )
													SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	SCREAMING_SNAKE_CASE  ,	SCREAMING_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]
										SCREAMING_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							,  )
													SCREAMING_SNAKE_CASE     =       False

										if do_normalize:
													SCREAMING_SNAKE_CASE     =       self.normalize(a      )

										return image







							def  _UpperCAmelCase  (       self							:						Dict							,  a							:						torch.FloatTensor							,  a							:						str = "pil"							,  a							:						Optional[List[bool]] = None							,  )      ->       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"]:
													SCREAMING_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      )
													SCREAMING_SNAKE_CASE     =       """np"""

										if output_type == "latent":
													return image

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

										SCREAMING_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

										SCREAMING_SNAKE_CASE     =       self.pt_to_numpy(a      )

										if output_type == "np":
													return image

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





class       UpperCAmelCase_   ( A							):




							'''simple docstring'''



							a__    	=  CONFIG_NAME





							@register_to_config
							def __init__(       self							:						Any							,  a							:						bool = True							,  a							:						int = 8							,  a							:						str = "lanczos"							,  a							:						bool = True							,  )      ->       Optional[int]:
										super().__init__()





							@staticmethod
							def  _UpperCAmelCase  (       a							:						str      )      ->       Optional[int]:
										if images.ndim == 3:
													SCREAMING_SNAKE_CASE     =       images[None, ...]
										SCREAMING_SNAKE_CASE     =       (images * 255).round().astype("""uint8"""      )
										if images.shape[-1] == 1:
													# special case for grayscale (single channel) images
													SCREAMING_SNAKE_CASE     =       [Image.fromarray(image.squeeze()							,  mode="""L"""      ) for image in images]
										else:
													SCREAMING_SNAKE_CASE     =       [Image.fromarray(image[:, :, :3]      ) for image in images]

										return pil_images





							@staticmethod
							def  _UpperCAmelCase  (       a							:						List[str]      )      ->       Union[str, Any]:
										return image[:, :, 1] * 2**8 + image[:, :, 2]





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

										return pil_images







							def  _UpperCAmelCase  (       self							:						str							,  a							:						torch.FloatTensor							,  a							:						str = "pil"							,  a							:						Optional[List[bool]] = None							,  )      ->       Optional[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"]:
													SCREAMING_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      )
													SCREAMING_SNAKE_CASE     =       """np"""

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

										SCREAMING_SNAKE_CASE     =       torch.stack(
										    [self.denormalize(image[i]      ) if do_denormalize[i] else image[i] for i in range(image.shape[0]      )]      )

										SCREAMING_SNAKE_CASE     =       self.pt_to_numpy(a      )

										if output_type == "np":
													if image.shape[-1] == 6:
																SCREAMING_SNAKE_CASE     =       np.stack([self.rgblike_to_depthmap(im[:, :, 3:]      ) for im in image]							,  axis=0      )
													else:
																SCREAMING_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"""      )












def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			if n == 0:
						return 1

			elif n % 2 == 1:
						return binary_exponentiation(SCREAMING_SNAKE_CASE       ,						n - 1 ) * a

			else:
						SCREAMING_SNAKE_CASE     =       binary_exponentiation(SCREAMING_SNAKE_CASE       ,						n / 2 )
						return b * b


if __name__ == "__main__":
		try:
				__A    :				Tuple    						=	int(input("""Enter Base : """).strip())
				__A    :				Any    						=	int(input("""Enter Power : """).strip())
		except ValueError:
				print("""Invalid literal for integer""")

		__A    :				Union[str, Any]    						=	binary_exponentiation(BASE, POWER)
		print(f'''{BASE}^({POWER}) : {RESULT}''')






