"""simple docstring"""
import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch



class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

										# Force fetching the files so that we can use the cache
										snake_case								=			'hf-internal-testing/tiny-random-bert'
										BertConfig.from_pretrained(lowerCAmelCase    )
										BertModel.from_pretrained(lowerCAmelCase    )
										BertTokenizer.from_pretrained(lowerCAmelCase    )
										pipeline(task='fill-mask'		,    model=lowerCAmelCase    )

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run, mock]    )]

										# should succeed
										snake_case								=			self.get_env()
										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

										# Force fetching the files so that we can use the cache
										snake_case								=			'hf-internal-testing/tiny-random-bert'
										BertConfig.from_pretrained(lowerCAmelCase    )
										BertModel.from_pretrained(lowerCAmelCase    )
										BertTokenizer.from_pretrained(lowerCAmelCase    )
										pipeline(task='fill-mask'		,    model=lowerCAmelCase    )

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run, mock]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

										# next emulate no network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, mock, run]    )]

										# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
										# env["TRANSFORMERS_OFFLINE"] = "0"
										# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
										# self.assertEqual(result.returncode, 1, result.stderr)

										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import pipeline\n        '
										snake_case								=			'\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

										snake_case								=			'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
										snake_case								=			self.get_env()
										snake_case								=			'1'
										snake_case								=			[sys.executable, '-c', '\n'.join([load, mock, run]    )]
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    1		,    result.stderr    )
										self.assertIn(
										    'You cannot infer task automatically within `pipeline` when using offline mode'		,    result.stderr.decode().replace('\n'		,    ''    )		,    )

				@require_torch
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			'\nfrom transformers import AutoModel\n        '
										snake_case								=			'\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

										# baseline - just load from_pretrained with normal network
										snake_case								=			[sys.executable, '-c', '\n'.join([load, run]    )]

										# should succeed
										snake_case								=			self.get_env()
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )

										# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
										snake_case								=			'1'
										snake_case								=			subprocess.run(lowerCAmelCase		,    env=lowerCAmelCase		,    check=lowerCAmelCase		,    capture_output=lowerCAmelCase    )
										self.assertEqual(result.returncode		,    0		,    result.stderr    )
										self.assertIn('success'		,    result.stdout.decode()    )



"""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()


