code: 
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
  					import torch
  
  if is_vision_available():
  					from PIL import Image
  
  					from transformers import ViltImageProcessor
  
  class __UpperCamelCase    (							unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def __init__(							self							,			lowerCamelCase__							,			lowerCamelCase__=7							,			lowerCamelCase__=3							,			lowerCamelCase__=1_8							,			lowerCamelCase__=3_0							,			lowerCamelCase__=4_0_0							,			lowerCamelCase__=True							,			lowerCamelCase__=None							,			lowerCamelCase__=2							,			lowerCamelCase__=True							,			lowerCamelCase__=[0.5, 0.5, 0.5]							,			lowerCamelCase__=[0.5, 0.5, 0.5]							,			):
  						UpperCAmelCase__:  str		       =   size if size is not None else {"shortest_edge": 3_0}
  						UpperCAmelCase__:  Optional[Any]		       =   parent
  						UpperCAmelCase__:  List[Any]		       =   batch_size
  						UpperCAmelCase__:  str		       =   num_channels
  						UpperCAmelCase__:  Optional[Any]		       =   image_size
  						UpperCAmelCase__:  List[str]		       =   min_resolution
  						UpperCAmelCase__:  List[Any]		       =   max_resolution
  						UpperCAmelCase__:  int		       =   do_resize
  						UpperCAmelCase__:  Tuple		       =   size
  						UpperCAmelCase__:  int		       =   size_divisor
  						UpperCAmelCase__:  Optional[Any]		       =   do_normalize
  						UpperCAmelCase__:  Optional[int]		       =   image_mean
  						UpperCAmelCase__:  Optional[int]		       =   image_std
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						return {
  						    "image_mean": self.image_mean,
  						    "image_std": self.image_std,
  						    "do_normalize": self.do_normalize,
  						    "do_resize": self.do_resize,
  						    "size": self.size,
  						    "size_divisor": self.size_divisor,
  						}
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__							,			lowerCamelCase__=False	):
  						if not batched:
  							UpperCAmelCase__:  Dict		       =   self.size["shortest_edge"]
  							UpperCAmelCase__:  int		       =   image_inputs[0]
  							if isinstance(lowerCamelCase__							,			Image.Image	):
  								UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   image.size
  							else:
  								UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   image.shape[1], image.shape[2]
  							UpperCAmelCase__:  int		       =   size / min(lowerCamelCase__							,			lowerCamelCase__	)
  							if h < w:
  								UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   size, scale * w
  							else:
  								UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   scale * h, size
  
  							UpperCAmelCase__:  List[str]		       =   int((1_3_3_3 / 8_0_0) * size	)
  							if max(lowerCamelCase__							,			lowerCamelCase__	) > max_size:
  								UpperCAmelCase__:  str		       =   max_size / max(lowerCamelCase__							,			lowerCamelCase__	)
  								UpperCAmelCase__:  Tuple		       =   newh * scale
  								UpperCAmelCase__:  Any		       =   neww * scale
  
  							UpperCAmelCase__       ,	UpperCAmelCase__:  List[str]		       =   int(newh + 0.5	), int(neww + 0.5	)
  							UpperCAmelCase__       ,	UpperCAmelCase__:  int		       =   (
  							    newh // self.size_divisor * self.size_divisor,
  							    neww // self.size_divisor * self.size_divisor,
  							)
  
  						else:
  							UpperCAmelCase__:  Tuple		       =   []
  							for image in image_inputs:
  								UpperCAmelCase__       ,	UpperCAmelCase__:  Union[str, Any]		       =   self.get_expected_values([image]	)
  								expected_values.append((expected_height, expected_width)	)
  							UpperCAmelCase__:  Optional[Any]		       =   max(lowerCamelCase__							,			key=lambda lowerCamelCase__	: item[0]	)[0]
  							UpperCAmelCase__:  Optional[int]		       =   max(lowerCamelCase__							,			key=lambda lowerCamelCase__	: item[1]	)[1]
  
  						return expected_height, expected_width
  
  @require_torch
  @require_vision
  class __UpperCamelCase    (							_a				,unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      ViltImageProcessor if is_vision_available() else None
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   ViltImageProcessingTester(self	)
  
  
  
  
  
  					@property
  					def       _UpperCAmelCase						(							self	):
  						return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  str		       =   self.image_processing_class(**self.image_processor_dict	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"image_mean"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"image_std"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"do_normalize"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"do_resize"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"size"	)	)
  						self.assertTrue(hasattr(lowerCamelCase__							,			"size_divisor"	)	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Union[str, Any]		       =   self.image_processing_class.from_dict(self.image_processor_dict	)
  						self.assertEqual(image_processor.size							,			{"shortest_edge": 3_0}	)
  
  						UpperCAmelCase__:  Dict		       =   self.image_processing_class.from_dict(self.image_processor_dict							,			size=4_2	)
  						self.assertEqual(image_processor.size							,			{"shortest_edge": 4_2}	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						pass
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Dict		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random PIL images
  						UpperCAmelCase__:  Any		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			Image.Image	)
  
  						# Test not batched input
  						UpperCAmelCase__:  Any		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Union[str, Any]		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,			)
  
  						# Test batched
  						UpperCAmelCase__:  List[str]		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__							,			batched=lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        expected_height,
  						        expected_width,
  						    )							,			)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Dict		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random numpy tensors
  						UpperCAmelCase__:  List[str]		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__							,			numpify=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			np.ndarray	)
  
  						# Test not batched input
  						UpperCAmelCase__:  List[Any]		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Tuple		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,			)
  
  						# Test batched
  						UpperCAmelCase__:  int		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Tuple		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__							,			batched=lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        expected_height,
  						        expected_width,
  						    )							,			)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						# Initialize image_processing
  						UpperCAmelCase__:  Tuple		       =   self.image_processing_class(**self.image_processor_dict	)
  						# create random PyTorch tensors
  						UpperCAmelCase__:  str		       =   prepare_image_inputs(self.image_processor_tester							,			equal_resolution=lowerCamelCase__							,			torchify=lowerCamelCase__	)
  						for image in image_inputs:
  							self.assertIsInstance(lowerCamelCase__							,			torch.Tensor	)
  
  						# Test not batched input
  						UpperCAmelCase__:  Union[str, Any]		       =   image_processing(image_inputs[0]							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,			)
  
  						# Test batched
  						UpperCAmelCase__:  str		       =   image_processing(lowerCamelCase__							,			return_tensors="pt"	).pixel_values
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Dict		       =   self.image_processor_tester.get_expected_values(lowerCamelCase__							,			batched=lowerCamelCase__	)
  						self.assertEqual(
  						    encoded_images.shape							,			(
  						        self.image_processor_tester.batch_size,
  						        self.image_processor_tester.num_channels,
  						        expected_height,
  						        expected_width,
  						    )							,			)
style_context: 
  
  from __future__ import annotations
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	assert n > 1 and a > 0 and greatest_common_divisor(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			) == 1
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)       ,	(UpperCAmelCase__)):  Optional[Any]		       =   extended_gcd(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)  # Implemented below
  	UpperCAmelCase__:  List[str]		       =   (b * s) % n
  	return x
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)):  int		       =   extended_euclid(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)  # Implemented below
  	if b < 0:
  		UpperCAmelCase__:  List[str]		       =   (b % n + n) % n
  	return b
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Union[str, Any]		       =   invert_modulo(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Any		       =   (b * s) % n
  	return x
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	assert a >= 0 and b >= 0
  
  	if b == 0:
  		UpperCAmelCase__       ,	UpperCAmelCase__       ,	UpperCAmelCase__:  List[Any]		       =   a, 1, 0
  	else:
  		((UpperCAmelCase__)       ,	(UpperCAmelCase__)       ,	(UpperCAmelCase__)):  Tuple		       =   extended_gcd(SCREAMING_SNAKE_CASE  ,a % b			)
  		UpperCAmelCase__:  Union[str, Any]		       =   q
  		UpperCAmelCase__:  Union[str, Any]		       =   p - q * (a // b)
  
  	assert a % d == 0 and b % d == 0
  	assert d == a * x + b * y
  
  	return (d, x, y)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if b == 0:
  		return (1, 0)
  	((UpperCAmelCase__)       ,	(UpperCAmelCase__)):  List[str]		       =   extended_euclid(SCREAMING_SNAKE_CASE  ,a % b			)
  	UpperCAmelCase__:  Optional[Any]		       =   a // b
  	return (y, x - k * y)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if a < b:
  		UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   b, a
  
  	while a % b != 0:
  		UpperCAmelCase__       ,	UpperCAmelCase__:  Union[str, Any]		       =   b, a % b
  
  	return b
  
  
  if __name__ == "__main__":
  					from doctest import testmod
  
  					testmod(name="""modular_division""", verbose=True)
  					testmod(name="""modular_division2""", verbose=True)
  					testmod(name="""invert_modulo""", verbose=True)
  					testmod(name="""extended_gcd""", verbose=True)
  					testmod(name="""extended_euclid""", verbose=True)
  					testmod(name="""greatest_common_divisor""", verbose=True)