"""simple docstring"""




import json
import os
import unittest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class     UpperCamelCase__(			__A		,						unittest.TestCase ):
						lowerCAmelCase__  :						Optional[Any]													=		MgpstrTokenizer
						lowerCAmelCase__  :						Union[str, Any]													=		False
						lowerCAmelCase__  :						List[str]													=		{}
						lowerCAmelCase__  :						Dict													=		False





						def 				snake_case__	(       self     )					->				int:
													super().setUp()

													# fmt: off
													A__	     =							['[GO]', '[s]', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
													# fmt: on
													A__	     =							dict(zip(__UpperCAmelCase		,range(len(__UpperCAmelCase     )     )     )     )

													A__	     =							os.path.join(self.tmpdirname		,VOCAB_FILES_NAMES['vocab_file']     )
													with open(self.vocab_file		,'w'		,encoding='utf-8'     ) as fp:
																				fp.write(json.dumps(__UpperCAmelCase     ) + '\n'     )





						def 				snake_case__	(       self		,**__UpperCAmelCase     )					->				Dict:
													return MgpstrTokenizer.from_pretrained(self.tmpdirname		,**__UpperCAmelCase     )





						def 				snake_case__	(       self		,__UpperCAmelCase     )					->				Dict:
													A__	     =							'tester'
													A__	     =							'tester'
													return input_text, output_text





						@unittest.skip('MGP-STR always lower cases letters.'     )
						def 				snake_case__	(       self     )					->				Optional[int]:
													pass





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							self.get_tokenizers(do_lower_case=__UpperCAmelCase     )
													for tokenizer in tokenizers:
																				with self.subTest(f'''{tokenizer.__class__.__name__}'''     ):
																											A__	     =							'[SPECIAL_TOKEN]'

																											tokenizer.add_special_tokens({'cls_token': special_token}     )
																											A__	     =							tokenizer.encode([special_token]		,add_special_tokens=__UpperCAmelCase     )
																											self.assertEqual(len(__UpperCAmelCase     )		,1     )

																											A__	     =							tokenizer.decode(__UpperCAmelCase		,skip_special_tokens=__UpperCAmelCase     )
																											self.assertTrue(special_token not in decoded     )





						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =							self.get_tokenizers()
													for tokenizer in tokenizers:
																				with self.subTest(f'''{tokenizer.__class__.__name__}'''     ):
																											A__     ,  A__	     =							self.get_input_output_texts(__UpperCAmelCase     )

																											A__	     =							tokenizer.tokenize(__UpperCAmelCase     )
																											A__	     =							tokenizer.convert_tokens_to_ids(__UpperCAmelCase     )
																											A__	     =							tokenizer.encode(__UpperCAmelCase		,add_special_tokens=__UpperCAmelCase     )
																											self.assertListEqual(__UpperCAmelCase		,__UpperCAmelCase     )

																											A__	     =							tokenizer.convert_ids_to_tokens(__UpperCAmelCase     )
																											self.assertNotEqual(len(__UpperCAmelCase     )		,0     )
																											A__	     =							tokenizer.decode(__UpperCAmelCase     )
																											self.assertIsInstance(__UpperCAmelCase		,__UpperCAmelCase     )

																											self.assertEqual(text_a.replace(' '		,''     )		,__UpperCAmelCase     )





						@unittest.skip('MGP-STR tokenizer only handles one sequence.'     )
						def 				snake_case__	(       self     )					->				List[str]:
													pass





						@unittest.skip('inputs cannot be pretokenized in MgpstrTokenizer'     )
						def 				snake_case__	(       self     )					->				Dict:
													pass






"""simple docstring"""




import numpy as np
from PIL import Image






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





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

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

							return updated_arr






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





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

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

							return updated_arr


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

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

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





