



"""simple docstring"""






import os
import unittest

from transformers.models.transfo_xl.tokenization_transfo_xl import VOCAB_FILES_NAMES, TransfoXLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin

class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_		,       unittest.TestCase       ):


					'''simple docstring'''





					_a             =							TransfoXLTokenizer
					_a             =							False
					_a             =							False



					def 		snake_case	(	self							:  List[Any]					)-> Tuple:
								super().setUp()

								lowerCamelCase__		:		Union[str, Any]		     =[
								    '''<unk>''',
								    '''[CLS]''',
								    '''[SEP]''',
								    '''want''',
								    '''unwanted''',
								    '''wa''',
								    '''un''',
								    '''running''',
								    ''',''',
								    '''low''',
								    '''l''',
								]
								lowerCamelCase__		:		List[Any]		     =os.path.join(self.tmpdirname,  VOCAB_FILES_NAMES['''vocab_file''']					)
								with open(self.vocab_file,  '''w''',  encoding='''utf-8'''					) as vocab_writer:
											vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]					)					)



					def 		snake_case	(	self							:  List[Any],  **lowerCamelCase							:  List[str]					)-> Dict:
								lowerCamelCase__		:		Optional[Any]		     =True
								return TransfoXLTokenizer.from_pretrained(self.tmpdirname,  **lowerCamelCase					)



					def 		snake_case	(	self							:  Optional[Any],  lowerCamelCase							:  Tuple					)-> str:
								lowerCamelCase__		:		int		     ='''<unk> UNwanted , running'''
								lowerCamelCase__		:		Optional[int]		     ='''<unk> unwanted, running'''
								return input_text, output_text



					def 		snake_case	(	self							:  List[Any]					)-> Union[str, Any]:
								lowerCamelCase__		:		str		     =TransfoXLTokenizer(vocab_file=self.vocab_file,  lower_case=lowerCamelCase					)

								lowerCamelCase__		:		str		     =tokenizer.tokenize('''<unk> UNwanted , running'''					)
								self.assertListEqual(lowerCamelCase,  ['''<unk>''', '''unwanted''', ''',''', '''running''']					)

								self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase					),  [0, 4, 8, 7]					)



					def 		snake_case	(	self							:  Tuple					)-> int:
								lowerCamelCase__		:		Optional[Any]		     =TransfoXLTokenizer(lower_case=lowerCamelCase					)

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHeLLo ! how  \n Are yoU ?  '''					),  ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']					)



					def 		snake_case	(	self							:  Optional[int]					)-> Union[str, Any]:
								lowerCamelCase__		:		str		     =TransfoXLTokenizer(lower_case=lowerCamelCase					)

								self.assertListEqual(
								    tokenizer.tokenize(''' \tHeLLo ! how  \n Are yoU ?  '''					),  ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']					)



					def 		snake_case	(	self							:  Any					)-> int:
								lowerCamelCase__		:		Union[str, Any]		     =TransfoXLTokenizer(lower_case=lowerCamelCase					)
								lowerCamelCase__		:		List[str]		     ='''Hello (bracket) and side-scrolled [and] Henry\'s $5,000 with 3.34 m. What\'s up!?'''
								lowerCamelCase__		:		Union[str, Any]		     =[
								    '''Hello''',
								    '''(''',
								    '''bracket''',
								    ''')''',
								    '''and''',
								    '''side''',
								    '''@-@''',
								    '''scrolled''',
								    '''[''',
								    '''and''',
								    ''']''',
								    '''Henry''',
								    '''\'s''',
								    '''$''',
								    '''5''',
								    '''@,@''',
								    '''000''',
								    '''with''',
								    '''3''',
								    '''@.@''',
								    '''34''',
								    '''m''',
								    '''.''',
								    '''What''',
								    '''\'s''',
								    '''up''',
								    '''!''',
								    '''?''',
								]

								self.assertListEqual(tokenizer.tokenize(lowerCamelCase					),  lowerCamelCase					)

								self.assertEqual(tokenizer.convert_tokens_to_string(lowerCamelCase					),  lowerCamelCase					)




					def 		snake_case	(	self							:  Tuple					)-> Optional[Any]:
								lowerCamelCase__		:		List[Any]		     =self.get_tokenizer()
								lowerCamelCase__		:		Dict		     =len(lowerCamelCase					)

								tokenizer.add_tokens(['''new1''', '''new2''']					)
								tokenizer.move_added_token('''new1''',  1					)

								# Check that moved token is not copied (duplicate)
								self.assertEqual(len(lowerCamelCase					),  original_len + 2					)
								# Check that token is moved to specified id
								self.assertEqual(tokenizer.encode('''new1'''					),  [1]					)
								self.assertEqual(tokenizer.decode([1]					),  '''new1'''					)









"""simple docstring"""






import numpy as np
from PIL import Image






def 					snake_case__       (		__lowerCamelCase    :   np.ndarray							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]		     =np.array(__lowerCamelCase     )
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('''The input array is not a square matrix'''     )
			lowerCamelCase__		:		int		     =0
			lowerCamelCase__		:		int		     =0
			lowerCamelCase__		:		Optional[int]		     =0
			lowerCamelCase__		:		List[Any]		     =0

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

			return updated_arr






def 					snake_case__       (		__lowerCamelCase    :   np.ndarray							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]		     =np.array(__lowerCamelCase     )
			if arr.shape[0] != arr.shape[1]:
						raise ValueError('''The input array is not a square matrix'''     )
			lowerCamelCase__		:		str		     =0
			lowerCamelCase__		:		List[Any]		     =0
			lowerCamelCase__		:		Optional[int]		     =0
			lowerCamelCase__		:		List[Any]		     =0

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

			return updated_arr


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

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

		# Loading the image
		_lowercase			:			int										=						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()




