"""simple docstring"""
import json
import os
import unittest

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES, XLMTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin



class   lowerCAmelCase_    (			lowerCAmelCase     ,    unittest.TestCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Optional[int]			  =						XLMTokenizer
				_lowerCAmelCase     :    List[Any]			  =						False

				def 		snake_case (				self    ):






										"""simple docstring"""

										super().setUp()

										# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
										snake_case								=			[
										    'l',
										    'o',
										    'w',
										    'e',
										    'r',
										    's',
										    't',
										    'i',
										    'd',
										    'n',
										    'w</w>',
										    'r</w>',
										    't</w>',
										    'lo',
										    'low',
										    'er</w>',
										    'low</w>',
										    'lowest</w>',
										    'newer</w>',
										    'wider</w>',
										    '<unk>',
										]
										snake_case								=			dict(zip(lowerCAmelCase		,    range(len(lowerCAmelCase    )    )    )    )
										snake_case								=			['l o 123', 'lo w 1456', 'e r</w> 1789', '']

										snake_case								=			os.path.join(self.tmpdirname		,    VOCAB_FILES_NAMES['vocab_file']    )
										snake_case								=			os.path.join(self.tmpdirname		,    VOCAB_FILES_NAMES['merges_file']    )
										with open(self.vocab_file		,    'w'    ) as fp:
																fp.write(json.dumps(lowerCAmelCase    )    )
										with open(self.merges_file		,    'w'    ) as fp:
																fp.write('\n'.join(lowerCAmelCase    )    )

				def 		snake_case (				self		,    lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			'lower newer'
										snake_case								=			'lower newer'
										return input_text, output_text

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			XLMTokenizer(self.vocab_file		,    self.merges_file    )

										snake_case								=			'lower'
										snake_case								=			['low', 'er</w>']
										snake_case								=			tokenizer.tokenize(lowerCAmelCase    )
										self.assertListEqual(lowerCAmelCase		,    lowerCAmelCase    )

										snake_case								=			tokens + ['<unk>']
										snake_case								=			[14, 15, 20]
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase    )		,    lowerCAmelCase    )

				@slow
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			XLMTokenizer.from_pretrained('xlm-mlm-en-2048'    )

										snake_case								=			tokenizer.encode('sequence builders'		,    add_special_tokens=lowerCAmelCase    )
										snake_case								=			tokenizer.encode('multi-sequence build'		,    add_special_tokens=lowerCAmelCase    )

										snake_case								=			tokenizer.build_inputs_with_special_tokens(lowerCAmelCase    )
										snake_case								=			tokenizer.build_inputs_with_special_tokens(lowerCAmelCase		,    lowerCAmelCase    )

										assert encoded_sentence == [0] + text + [1]
										assert encoded_pair == [0] + text + [1] + text_a + [1]



"""simple docstring"""
import numpy as np
from PIL import Image





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






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

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

						return updated_arr





def    lowerCAmelCase__    (			_UpperCamelCase       :				np.ndarray ,			_UpperCamelCase       :				int ,			_UpperCamelCase       :				int					)					->				np.ndarray:





						"""simple docstring"""






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

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

						return updated_arr


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

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

					# Loading the image
					SCREAMING_SNAKE_CASE__      						=  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()


