import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType





class UpperCAmelCase		(   __A    ):


				'''simple docstring'''






				lowerCamelCase_        =   ['''image_processor''', '''tokenizer''']
				lowerCamelCase_        =   '''ViltImageProcessor'''
				lowerCamelCase_        =   ('''BertTokenizer''', '''BertTokenizerFast''')
				def __init__(		self						,      lowercase=None						,      lowercase=None						,      **lowercase   ):



						"""simple docstring"""





						A_						:							Tuple      = None
						if "feature_extractor" in kwargs:
								warnings.warn(
								    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
								    ' instead.'						,      lowercase						,      )
								A_						:							Any      = kwargs.pop('feature_extractor'   )

						A_						:							int      = image_processor if image_processor is not None else feature_extractor
						if image_processor is None:
								raise ValueError('You need to specify an `image_processor`.'   )
						if tokenizer is None:
								raise ValueError('You need to specify a `tokenizer`.'   )

						super().__init__(lowercase						,      lowercase   )
						A_						:							Union[str, Any]      = self.image_processor
				def __call__(		self						,      lowercase						,      lowercase = None						,      lowercase = True						,      lowercase = False						,      lowercase = None						,      lowercase = None						,      lowercase = 0						,      lowercase = None						,      lowercase = None						,      lowercase = None						,      lowercase = False						,      lowercase = False						,      lowercase = False						,      lowercase = False						,      lowercase = True						,      lowercase = None						,      **lowercase						,      ):



						"""simple docstring"""





						A_						:							List[Any]      = self.tokenizer(
						    text=lowercase						,      add_special_tokens=lowercase						,      padding=lowercase						,      truncation=lowercase						,      max_length=lowercase						,      stride=lowercase						,      pad_to_multiple_of=lowercase						,      return_token_type_ids=lowercase						,      return_attention_mask=lowercase						,      return_overflowing_tokens=lowercase						,      return_special_tokens_mask=lowercase						,      return_offsets_mapping=lowercase						,      return_length=lowercase						,      verbose=lowercase						,      return_tensors=lowercase						,      **lowercase						,      )
						# add pixel_values + pixel_mask
						A_						:							List[str]      = self.image_processor(lowercase						,      return_tensors=lowercase   )
						encoding.update(lowercase   )

						return encoding
				def     lowerCAmelCase_  (		self						,      *lowercase						,      **lowercase   ):



						"""simple docstring"""





						return self.tokenizer.batch_decode(*lowercase						,      **lowercase   )
				def     lowerCAmelCase_  (		self						,      *lowercase						,      **lowercase   ):



						"""simple docstring"""





						return self.tokenizer.decode(*lowercase						,      **lowercase   )
				@property
				def     lowerCAmelCase_  (		self   ):



						"""simple docstring"""





						A_						:							List[Any]      = self.tokenizer.model_input_names
						A_						:							Optional[int]      = self.image_processor.model_input_names
						return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )
				@property
				def     lowerCAmelCase_  (		self   ):



						"""simple docstring"""





						warnings.warn(
						    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'						,      lowercase						,      )
						return self.image_processor_class







				@property
				def     lowerCAmelCase_  (		self   ):



						"""simple docstring"""





						warnings.warn(
						    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'						,      lowercase						,      )
						return self.image_processor







import numpy as np
from PIL import Image




def 							UpperCamelCase		(			__lowercase		:					np.ndarray		,__lowercase		:					int		,__lowercase		:					int      ):
		'''simple docstring'''




		A_						:							List[Any]      = np.array(__lowercase      )
		if arr.shape[0] != arr.shape[1]:
				raise ValueError('The input array is not a square matrix'      )
		A_						:							str      = 0
		A_						:							Any      = 0
		A_						:							Optional[int]      = 0
		A_						:							Optional[Any]      = 0

		# compute the shape of the output matrix
		A_						:							str      = (arr.shape[0] - size) // stride + 1
		# initialize the output matrix with zeros of shape maxpool_shape
		A_						:							str      = np.zeros((maxpool_shape, maxpool_shape)      )

		while i < arr.shape[0]:
				if i + size > arr.shape[0]:
						# if the end of the matrix is reached, break
						break
				while j < arr.shape[1]:
						# if the end of the matrix is reached, break
						if j + size > arr.shape[1]:
								break
						# compute the maximum of the pooling matrix
						A_						:							Any      = np.max(arr[i : i + size, j : j + size]      )
						# shift the pooling matrix by stride of column pixels
						j += stride
						mat_j += 1

				# shift the pooling matrix by stride of row pixels
				i += stride
				mat_i += 1

				# reset the column index to 0
				A_						:							Tuple      = 0
				A_						:							Optional[int]      = 0

		return updated_arr




def 							UpperCamelCase		(			__lowercase		:					np.ndarray		,__lowercase		:					int		,__lowercase		:					int      ):
		'''simple docstring'''




		A_						:							int      = np.array(__lowercase      )
		if arr.shape[0] != arr.shape[1]:
				raise ValueError('The input array is not a square matrix'      )
		A_						:							Any      = 0
		A_						:							Optional[int]      = 0
		A_						:							List[str]      = 0
		A_						:							Union[str, Any]      = 0

		# compute the shape of the output matrix
		A_						:							int      = (arr.shape[0] - size) // stride + 1
		# initialize the output matrix with zeros of shape avgpool_shape
		A_						:							int      = np.zeros((avgpool_shape, avgpool_shape)      )

		while i < arr.shape[0]:
				# if the end of the matrix is reached, break
				if i + size > arr.shape[0]:
						break
				while j < arr.shape[1]:
						# if the end of the matrix is reached, break
						if j + size > arr.shape[1]:
								break
						# compute the average of the pooling matrix
						A_						:							str      = int(np.average(arr[i : i + size, j : j + size]      )      )
						# shift the pooling matrix by stride of column pixels
						j += stride
						mat_j += 1

				# shift the pooling matrix by stride of row pixels
				i += stride
				mat_i += 1
				# reset the column index to 0
				A_						:							List[Any]      = 0
				A_						:							int      = 0

		return updated_arr


# Main Function
if __name__ == "__main__":
	from doctest import testmod

	testmod(name="""avgpooling""", verbose=True)

	# Loading the image
	_UpperCAmelCase          =						Image.open("""path_to_image""")

	# Converting the image to numpy array and maxpooling, displaying the result
	# Ensure that the image is a square matrix

	Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

	# Converting the image to numpy array and averagepooling, displaying the result
	# Ensure that the image is a square matrix

	Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()






