import numpy as np
from PIL import Image




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




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

		# compute the shape of the output matrix
		A_		:    Tuple         =				(arr.shape[0] - size) // stride + 1
		# initialize the output matrix with zeros of shape maxpool_shape
		A_		:    Any         =				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_		:    Optional[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_		:    List[Any]         =				0
				A_		:    List[str]         =				0

		return updated_arr




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




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

		# compute the shape of the output matrix
		A_		:    List[Any]         =				(arr.shape[0] - size) // stride + 1
		# initialize the output matrix with zeros of shape avgpool_shape
		A_		:    Union[str, Any]         =				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_		:    int         =				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_		:    Optional[int]         =				0
				A_		:    Optional[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()







_UpperCAmelCase            =		"""ABCDEFGHIJKLMNOPQRSTUVWXYZ"""




def     UpperCamelCase						(	):
		'''simple docstring'''




		A_		:    Tuple         =				input('Enter message: '     )
		A_		:    int         =				input('Enter key [alphanumeric]: '     )
		A_		:    Optional[Any]         =				input('Encrypt/Decrypt [e/d]: '     )

		if mode.lower().startswith('e'     ):
				A_		:    List[Any]         =				'encrypt'
				A_		:    int         =				encrypt_message(__lowercase						,__lowercase     )
		elif mode.lower().startswith('d'     ):
				A_		:    Optional[Any]         =				'decrypt'
				A_		:    Dict         =				decrypt_message(__lowercase						,__lowercase     )

		print(f'''\n{mode.title()}ed message:'''     )
		print(__lowercase     )




def     UpperCamelCase						(	__lowercase						:			str						,__lowercase						:			str     ):
		'''simple docstring'''




		return translate_message(__lowercase						,__lowercase						,'encrypt'     )




def     UpperCamelCase						(	__lowercase						:			str						,__lowercase						:			str     ):
		'''simple docstring'''




		return translate_message(__lowercase						,__lowercase						,'decrypt'     )




def     UpperCamelCase						(	__lowercase						:			str						,__lowercase						:			str						,__lowercase						:			str     ):
		'''simple docstring'''




		A_		:    Tuple         =				[]
		A_		:    str         =				0
		A_		:    Optional[int]         =				key.upper()

		for symbol in message:
				A_		:    Optional[Any]         =				LETTERS.find(symbol.upper()     )
				if num != -1:
						if mode == "encrypt":
								num += LETTERS.find(key[key_index]     )
						elif mode == "decrypt":
								num -= LETTERS.find(key[key_index]     )

						num %= len(__lowercase     )

						if symbol.isupper():
								translated.append(LETTERS[num]     )
						elif symbol.islower():
								translated.append(LETTERS[num].lower()     )

						key_index += 1
						if key_index == len(__lowercase     ):
								A_		:    str         =				0
				else:
						translated.append(__lowercase     )
		return "".join(__lowercase     )


if __name__ == "__main__":
	main()






