






"""simple docstring"""



import numpy as np
from PIL import Image



def 						lowercase    (				__snake_case				: np.ndarray		,					__snake_case				: int		,					__snake_case				: int	):
		lowercase_ : Tuple							       =   np.array(__snake_case	)
		if arr.shape[0] != arr.shape[1]:
				raise ValueError('''The input array is not a square matrix'''	)
		lowercase_ : Dict							       =   0
		lowercase_ : Any							       =   0
		lowercase_ : List[str]							       =   0
		lowercase_ : Union[str, Any]							       =   0

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

		return updated_arr



def 						lowercase    (				__snake_case				: np.ndarray		,					__snake_case				: int		,					__snake_case				: int	):
		lowercase_ : int							       =   np.array(__snake_case	)
		if arr.shape[0] != arr.shape[1]:
				raise ValueError('''The input array is not a square matrix'''	)
		lowercase_ : int							       =   0
		lowercase_ : Dict							       =   0
		lowercase_ : Tuple							       =   0
		lowercase_ : Tuple							       =   0

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

		return updated_arr


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

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

						# Loading the image
						__A		:       List[Any]  				=		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 TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


__A		:       Union[str, Any]  				=		{}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__A		:       Dict  				=		['''NllbTokenizer''']

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__A		:       Dict  				=		['''NllbTokenizerFast''']


if TYPE_CHECKING:
						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_nllb import NllbTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_nllb_fast import NllbTokenizerFast

else:
						import sys

						__A		:       List[Any]  				=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



