"""simple docstring"""





from importlib import import_module

from .logging import get_logger


__A     = get_logger(__name__)
class        _snake_case   :






						def __init__(				self					:	Optional[int]							,    UpperCAmelCase					:	List[Any]							,    UpperCAmelCase					:	int=None			):
													__lowerCamelCase    :						Tuple						      =   attrs or []
													if module is not None:
																				for key in module.__dict__:
																											if key in attrs or not key.startswith("__"			):
																																		setattr(self							,    UpperCAmelCase							,    getattr(UpperCAmelCase							,    UpperCAmelCase			)			)
													__lowerCamelCase    :						Any						      =   module._original_module if isinstance(UpperCAmelCase							,    _PatchedModuleObj			) else module

class        _snake_case   :
						snake_case__	     =	[]






						def __init__(				self					:	str							,    UpperCAmelCase					:	Tuple							,    UpperCAmelCase					:	str							,    UpperCAmelCase					:	List[str]							,    UpperCAmelCase					:	Optional[Any]=None			):
													__lowerCamelCase    :						int						      =   obj
													__lowerCamelCase    :						Union[str, Any]						      =   target
													__lowerCamelCase    :						List[str]						      =   new
													__lowerCamelCase    :						Optional[int]						      =   target.split("."			)[0]
													__lowerCamelCase    :						Tuple						      =   {}
													__lowerCamelCase    :						Union[str, Any]						      =   attrs or []






						def __enter__(				self					:	Dict			):
													__lowerCamelCase    :						str						      =   self.target.split("."			)

													# Patch modules:
													# it's used to patch attributes of submodules like "os.path.join";
													# in this case we need to patch "os" and "os.path"

													for i in range(len(UpperCAmelCase			)			):
																				try:
																											__lowerCamelCase    :						List[Any]						      =   import_module(".".join(submodules[: i + 1]			)			)
																				except ModuleNotFoundError:
																											continue
																				# We iterate over all the globals in self.obj in case we find "os" or "os.path"
																				for attr in self.obj.__dir__():
																											__lowerCamelCase    :						List[Any]						      =   getattr(self.obj							,    UpperCAmelCase			)
																											# We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
																											# This allows to patch renamed modules like "from os import path as ospath".
																											if obj_attr is submodule or (
																											    (isinstance(UpperCAmelCase							,    _PatchedModuleObj			) and obj_attr._original_module is submodule)
																											):
																																		__lowerCamelCase    :						Tuple						      =   obj_attr
																																		# patch at top level
																																		setattr(self.obj							,    UpperCAmelCase							,    _PatchedModuleObj(UpperCAmelCase							,    attrs=self.attrs			)			)
																																		__lowerCamelCase    :						int						      =   getattr(self.obj							,    UpperCAmelCase			)
																																		# construct lower levels patches
																																		for key in submodules[i + 1 :]:
																																									setattr(UpperCAmelCase							,    UpperCAmelCase							,    _PatchedModuleObj(getattr(UpperCAmelCase							,    UpperCAmelCase							,    UpperCAmelCase			)							,    attrs=self.attrs			)			)
																																									__lowerCamelCase    :						Optional[int]						      =   getattr(UpperCAmelCase							,    UpperCAmelCase			)
																																		# finally set the target attribute
																																		setattr(UpperCAmelCase							,    UpperCAmelCase							,    self.new			)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

													if submodules:  # if it's an attribute of a submodule like "os.path.join"
																				try:
																											__lowerCamelCase    :						int						      =   getattr(import_module(".".join(UpperCAmelCase			)			)							,    UpperCAmelCase			)
																				except (AttributeError, ModuleNotFoundError):
																											return
																				# We iterate over all the globals in self.obj in case we find "os.path.join"
																				for attr in self.obj.__dir__():
																											# We don't check for the name of the global, but rather if its value *is* "os.path.join".
																											# This allows to patch renamed attributes like "from os.path import join as pjoin".
																											if getattr(self.obj							,    UpperCAmelCase			) is attr_value:
																																		__lowerCamelCase    :						Union[str, Any]						      =   getattr(self.obj							,    UpperCAmelCase			)
																																		setattr(self.obj							,    UpperCAmelCase							,    self.new			)
													elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
																				__lowerCamelCase    :						str						      =   globals()["""__builtins__"""][target_attr]
																				setattr(self.obj							,    UpperCAmelCase							,    self.new			)
													else:
																				raise RuntimeError(F"""Tried to patch attribute {target_attr} instead of a submodule."""			)






						def __exit__(				self					:	str							,    *UpperCAmelCase					:	Optional[int]			):






													for attr in list(self.original			):
																				setattr(self.obj							,    UpperCAmelCase							,    self.original.pop(UpperCAmelCase			)			)






						def 					lowerCamelCase__   (				self					:	int			):
													self.__enter__()
													self._active_patches.append(self			)







						def 					lowerCamelCase__   (				self					:	List[Any]			):






													try:
																				self._active_patches.remove(self			)
													except ValueError:
																				# If the patch hasn't been started this will fail
																				return None

													return self.__exit__()



"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
							import PIL


UpperCAmelCase    :     Optional[Any]   						=		logging.get_logger(__name__)
def      lowerCamelCase       (     _UpperCamelCase		:      Any       ,			_UpperCamelCase		:      Optional[Any]							)		->       int:

							'''simple docstring'''



							__UpperCAmelCase   :						int      							=					b.T
							__UpperCAmelCase   :						Union[str, Any]      							=					np.sum(np.square(_UpperCamelCase							)       ,			axis=1							)
							__UpperCAmelCase   :						List[Any]      							=					np.sum(np.square(_UpperCamelCase							)       ,			axis=0							)
							__UpperCAmelCase   :						int      							=					np.matmul(_UpperCamelCase       ,			_UpperCamelCase							)
							__UpperCAmelCase   :						Tuple      							=					aa[:, None] - 2 * ab + ba[None, :]
							return d
def      lowerCamelCase       (     _UpperCamelCase		:      Tuple       ,			_UpperCamelCase		:      Optional[Any]							)		->       Optional[int]:

							'''simple docstring'''



							__UpperCAmelCase   :						Tuple      							=					x.reshape(-1       ,			3							)
							__UpperCAmelCase   :						Optional[Any]      							=					squared_euclidean_distance(_UpperCamelCase       ,			_UpperCamelCase							)
							return np.argmin(_UpperCamelCase       ,			axis=1							)





class      lowerCamelCase__   (     A				):







					"""simple docstring"""


					__a	       =							["""pixel_values"""]






					def __init__(       self    : List[str] ,       UpperCamelCase    : Optional[Union[List[List[int]], np.ndarray]] = None ,       UpperCamelCase    : bool = True ,       UpperCamelCase    : Dict[str, int] = None ,       UpperCamelCase    : PILImageResampling = PILImageResampling.BILINEAR ,       UpperCamelCase    : bool = True ,       UpperCamelCase    : bool = True ,       **UpperCamelCase    : int ,       ):
												'''simple docstring'''






												super().__init__(**UpperCamelCase  )
												__UpperCAmelCase   :						Optional[Any]      							=					size if size is not None else {"""height""": 256, """width""": 256}
												__UpperCAmelCase   :						Tuple      							=					get_size_dict(UpperCamelCase  )
												__UpperCAmelCase   :						Union[str, Any]      							=					np.array(UpperCamelCase  ) if clusters is not None else None
												__UpperCAmelCase   :						int      							=					do_resize
												__UpperCAmelCase   :						List[str]      							=					size
												__UpperCAmelCase   :						Dict      							=					resample
												__UpperCAmelCase   :						int      							=					do_normalize
												__UpperCAmelCase   :						List[Any]      							=					do_color_quantize






					def lowerCamelCase__							(       self    : List[str] ,       UpperCamelCase    : np.ndarray ,       UpperCamelCase    : Dict[str, int] ,       UpperCamelCase    : PILImageResampling = PILImageResampling.BILINEAR ,       UpperCamelCase    : Optional[Union[str, ChannelDimension]] = None ,       **UpperCamelCase    : str ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						Any      							=					get_size_dict(UpperCamelCase  )
												if "height" not in size or "width" not in size:
																			raise ValueError(f'''Size dictionary must contain both height and width keys. Got {size.keys()}'''  )
												return resize(
												    UpperCamelCase ,       size=(size["""height"""], size["""width"""]) ,       resample=UpperCamelCase ,       data_format=UpperCamelCase ,       **UpperCamelCase  )






					def lowerCamelCase__							(       self    : Dict ,       UpperCamelCase    : np.ndarray ,       UpperCamelCase    : Optional[Union[str, ChannelDimension]] = None ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						Optional[Any]      							=					rescale(image=UpperCamelCase ,       scale=1 / 127.5 ,       data_format=UpperCamelCase  )
												__UpperCAmelCase   :						Optional[Any]      							=					image - 1
												return image






					def lowerCamelCase__							(       self    : Dict ,       UpperCamelCase    : ImageInput ,       UpperCamelCase    : bool = None ,       UpperCamelCase    : Dict[str, int] = None ,       UpperCamelCase    : PILImageResampling = None ,       UpperCamelCase    : bool = None ,       UpperCamelCase    : Optional[bool] = None ,       UpperCamelCase    : Optional[Union[List[List[int]], np.ndarray]] = None ,       UpperCamelCase    : Optional[Union[str, TensorType]] = None ,       UpperCamelCase    : Optional[Union[str, ChannelDimension]] = ChannelDimension.FIRST ,       **UpperCamelCase    : Optional[int] ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					do_resize if do_resize is not None else self.do_resize
												__UpperCAmelCase   :						Any      							=					size if size is not None else self.size
												__UpperCAmelCase   :						Any      							=					get_size_dict(UpperCamelCase  )
												__UpperCAmelCase   :						Optional[Any]      							=					resample if resample is not None else self.resample
												__UpperCAmelCase   :						Any      							=					do_normalize if do_normalize is not None else self.do_normalize
												__UpperCAmelCase   :						Any      							=					do_color_quantize if do_color_quantize is not None else self.do_color_quantize
												__UpperCAmelCase   :						Tuple      							=					clusters if clusters is not None else self.clusters
												__UpperCAmelCase   :						Tuple      							=					np.array(UpperCamelCase  )

												__UpperCAmelCase   :						int      							=					make_list_of_images(UpperCamelCase  )

												if not valid_images(UpperCamelCase  ):
																			raise ValueError(
																			    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
																			    """torch.Tensor, tf.Tensor or jax.ndarray."""  )

												if do_resize and size is None or resample is None:
																			raise ValueError("""Size and resample must be specified if do_resize is True."""  )

												if do_color_quantize and clusters is None:
																			raise ValueError("""Clusters must be specified if do_color_quantize is True."""  )

												# All transformations expect numpy arrays.
												__UpperCAmelCase   :						Tuple      							=					[to_numpy_array(UpperCamelCase  ) for image in images]

												if do_resize:
																			__UpperCAmelCase   :						Dict      							=					[self.resize(image=UpperCamelCase ,       size=UpperCamelCase ,       resample=UpperCamelCase  ) for image in images]

												if do_normalize:
																			__UpperCAmelCase   :						Any      							=					[self.normalize(image=UpperCamelCase  ) for image in images]

												if do_color_quantize:
																			__UpperCAmelCase   :						str      							=					[to_channel_dimension_format(UpperCamelCase ,       ChannelDimension.LAST  ) for image in images]
																			# color quantize from (batch_size, height, width, 3) to (batch_size, height, width)
																			__UpperCAmelCase   :						Optional[int]      							=					np.array(UpperCamelCase  )
																			__UpperCAmelCase   :						Any      							=					color_quantize(UpperCamelCase ,       UpperCamelCase  ).reshape(images.shape[:-1]  )

																			# flatten to (batch_size, height*width)
																			__UpperCAmelCase   :						Dict      							=					images.shape[0]
																			__UpperCAmelCase   :						Optional[Any]      							=					images.reshape(UpperCamelCase ,       -1  )

																			# We need to convert back to a list of images to keep consistent behaviour across processors.
																			__UpperCAmelCase   :						int      							=					list(UpperCamelCase  )
												else:
																			__UpperCAmelCase   :						List[Any]      							=					[to_channel_dimension_format(UpperCamelCase ,       UpperCamelCase  ) for image in images]

												__UpperCAmelCase   :						List[str]      							=					{"""input_ids""": images}
												return BatchFeature(data=UpperCamelCase ,       tensor_type=UpperCamelCase  )
