"""simple docstring"""

import numpy as np
from PIL import Image






def      lowercase		(						a__	:		Optional[Any] ,  a__	:		str ,  a__	:		str     )						->   List[str]:
					_UpperCamelCase      						=	np.array(lowerCAmelCase_     )
					if arr.shape[0] != arr.shape[1]:
										raise ValueError('''The input array is not a square matrix'''     )
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0

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

					return updated_arr






def      lowercase		(						a__	:		List[str] ,  a__	:		Dict ,  a__	:		Dict     )						->   Union[str, Any]:
					_UpperCamelCase      						=	np.array(lowerCAmelCase_     )
					if arr.shape[0] != arr.shape[1]:
										raise ValueError('''The input array is not a square matrix'''     )
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0
					_UpperCamelCase      						=	0

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







import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs




@pytest.mark.parametrize(
    "kwargs, expected"  ,						[
        ({"num_shards": 0, "max_num_jobs": 1}, []),
        ({"num_shards": 10, "max_num_jobs": 1}, [range(10   )]),
        ({"num_shards": 10, "max_num_jobs": 10}, [range(lowerCAmelCase_  ,						i + 1   ) for i in range(10   )]),
        ({"num_shards": 1, "max_num_jobs": 10}, [range(1   )]),
        ({"num_shards": 10, "max_num_jobs": 3}, [range(0  ,						4   ), range(4  ,						7   ), range(7  ,						10   )]),
        ({"num_shards": 3, "max_num_jobs": 10}, [range(0  ,						1   ), range(1  ,						2   ), range(2  ,						3   )]),
    ]  ,						)
def    UpperCAmelCase__       (lowerCAmelCase_  ,						lowerCAmelCase_   ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						   =				_distribute_shards(**lowerCAmelCase_   )
					assert out == expected




@pytest.mark.parametrize(
    "gen_kwargs, max_num_jobs, expected"  ,						[
        ({"foo": 0}, 10, [{"foo": 0}]),
        ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]),
        ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]),
        ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]),
        ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]),
    ]  ,						)
def    UpperCAmelCase__       (lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_   ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						   =				_split_gen_kwargs(lowerCAmelCase_  ,						lowerCAmelCase_   )
					assert out == expected




@pytest.mark.parametrize(
    "gen_kwargs, expected"  ,						[
        ({"foo": 0}, 1),
        ({"shards": [0]}, 1),
        ({"shards": [0, 1, 2, 3]}, 4),
        ({"shards": [0, 1, 2, 3], "foo": 0}, 4),
        ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4),
        ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError),
    ]  ,						)
def    UpperCAmelCase__       (lowerCAmelCase_  ,						lowerCAmelCase_   ):




					'''simple docstring'''


					if expected is RuntimeError:
										with pytest.raises(lowerCAmelCase_   ):
															_number_of_shards_in_gen_kwargs(lowerCAmelCase_   )
					else:
										__SCREAMING_SNAKE_CASE						   =				_number_of_shards_in_gen_kwargs(lowerCAmelCase_   )
										assert out == expected
