


"""simple docstring"""

import numpy as np
from PIL import Image


def lowerCAmelCase_      (				UpperCamelCase__	: np.ndarray				,   UpperCamelCase__	: int				,   UpperCamelCase__	: int ):






 """simple docstring"""







 __lowercase									=	np.array(UpperCamelCase__ )
 if arr.shape[0] != arr.shape[1]:
  raise ValueError("""The input array is not a square matrix""" )
 __lowercase									=	0
 __lowercase									=	0
 __lowercase									=	0
 __lowercase									=	0

 # compute the shape of the output matrix
 __lowercase									=	(arr.shape[0] - size) // stride + 1
 # initialize the output matrix with zeros of shape maxpool_shape
 __lowercase									=	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
   __lowercase									=	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
  __lowercase									=	0
  __lowercase									=	0

 return updated_arr


def lowerCAmelCase_      (				UpperCamelCase__	: np.ndarray				,   UpperCamelCase__	: int				,   UpperCamelCase__	: int ):






 """simple docstring"""







 __lowercase									=	np.array(UpperCamelCase__ )
 if arr.shape[0] != arr.shape[1]:
  raise ValueError("""The input array is not a square matrix""" )
 __lowercase									=	0
 __lowercase									=	0
 __lowercase									=	0
 __lowercase									=	0

 # compute the shape of the output matrix
 __lowercase									=	(arr.shape[0] - size) // stride + 1
 # initialize the output matrix with zeros of shape avgpool_shape
 __lowercase									=	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
   __lowercase									=	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
  __lowercase									=	0
  __lowercase									=	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()




"""simple docstring"""

from typing import List

from .keymap import KEYMAP, get_character


def lowerCAmelCase_      (				UpperCamelCase__	: str ):






 """simple docstring"""







 def decorator(UpperCamelCase__	: Tuple ):
  __lowercase									=	getattr(UpperCamelCase__				,   """handle_key"""				,   [] )
  handle += [key]
  setattr(UpperCamelCase__				,   """handle_key"""				,   UpperCamelCase__ )
  return func

 return decorator


def lowerCAmelCase_      (				*UpperCamelCase__	: List[str] ):






 """simple docstring"""







 def decorator(UpperCamelCase__	: Tuple ):
  __lowercase									=	getattr(UpperCamelCase__				,   """handle_key"""				,   [] )
  handle += keys
  setattr(UpperCamelCase__				,   """handle_key"""				,   UpperCamelCase__ )
  return func

 return decorator





class    lowerCamelCase__						(		_a    ):
      def __new__(		cls	:	str      ,       A_	:	Optional[Any]      ,       A_	:	Union[str, Any]      ,       A_	:	int							):






       '''simple docstring'''


       __lowercase									=	super().__new__(cls      ,       A_      ,       A_      ,       A_							)
       if not hasattr(A_      ,       """key_handler"""							):
        setattr(A_      ,       """key_handler"""      ,       {}							)
       setattr(A_      ,       """handle_input"""      ,       KeyHandler.handle_input							)

       for value in attrs.values():
        __lowercase									=	getattr(A_      ,       """handle_key"""      ,       []							)
        for key in handled_keys:
         __lowercase									=	value
       return new_cls






      @staticmethod
      def SCREAMING_SNAKE_CASE_	(		cls	:	Dict							):






       '''simple docstring'''


       __lowercase									=	get_character()
       if char != KEYMAP["undefined"]:
        __lowercase									=	ord(A_							)
       __lowercase									=	cls.key_handler.get(A_							)
       if handler:
        __lowercase									=	char
        return handler(cls							)
       else:
        return None






def lowerCAmelCase_      (				cls	: int ):






 """simple docstring"""







 return KeyHandler(cls.__name__				,   cls.__bases__				,   cls.__dict__.copy() )
