



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


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import BlipImageProcessor







class 							a_  (		unittest.TestCase				):

						def __init__(    self	:Optional[int]   ,						_lowercase	:str   ,						_lowercase	:Tuple=7   ,						_lowercase	:str=3   ,						_lowercase	:Dict=18   ,						_lowercase	:int=30   ,						_lowercase	:int=400   ,						_lowercase	:Dict=True   ,						_lowercase	:int=None   ,						_lowercase	:List[Any]=True   ,						_lowercase	:int=False   ,						_lowercase	:Dict=[0.48_145_466, 0.4_578_275, 0.40_821_073]   ,						_lowercase	:Union[str, Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]   ,						_lowercase	:Optional[Any]=True   ,						)		->					int:
												UpperCAmelCase_     							=     size if size is not None else {'''height''': 20, '''width''': 20}
												UpperCAmelCase_     							=     parent
												UpperCAmelCase_     							=     batch_size
												UpperCAmelCase_     							=     num_channels
												UpperCAmelCase_     							=     image_size
												UpperCAmelCase_     							=     min_resolution
												UpperCAmelCase_     							=     max_resolution
												UpperCAmelCase_     							=     do_resize
												UpperCAmelCase_     							=     size
												UpperCAmelCase_     							=     do_normalize
												UpperCAmelCase_     							=     image_mean
												UpperCAmelCase_     							=     image_std
												UpperCAmelCase_     							=     do_pad
												UpperCAmelCase_     							=     do_convert_rgb

						def 	__a       (    self	:int)		->					Optional[int]:
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_convert_rgb": self.do_convert_rgb,
												    "do_pad": self.do_pad,
												}




						def 	__a       (    self	:Tuple   ,						_lowercase	:Dict=False   ,						_lowercase	:Union[str, Any]=False   ,						_lowercase	:Dict=False)		->					int:
												assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

												if equal_resolution:
																		UpperCAmelCase_     							=     []
																		for i in range(self.batch_size):
																								image_inputs.append(
																								    np.random.randint(
																								        255   ,						size=(self.num_channels, self.max_resolution, self.max_resolution)   ,						dtype=np.uinta))
												else:
																		UpperCAmelCase_     							=     []
																		for i in range(self.batch_size):
																								UpperCAmelCase_							,      UpperCAmelCase_     							=     np.random.choice(np.arange(self.min_resolution   ,						self.max_resolution)   ,						2)
																								image_inputs.append(np.random.randint(255   ,						size=(self.num_channels, width, height)   ,						dtype=np.uinta))

												if not numpify and not torchify:
																		# PIL expects the channel dimension as last dimension
																		UpperCAmelCase_     							=     [Image.fromarray(np.moveaxis(_lowercase   ,						0   ,						-1)) for x in image_inputs]

												if torchify:
																		UpperCAmelCase_     							=     [torch.from_numpy(_lowercase) for x in image_inputs]

												return image_inputs







@require_torch
@require_vision
class 							a_  (		_snake_case					, unittest.TestCase				):
						UpperCamelCase__      :						Tuple				       =BlipImageProcessor if is_vision_available() else None

						def 	__a       (    self	:Optional[int])		->					str:
												UpperCAmelCase_     							=     BlipImageProcessingTester(self)

						@property
						def 	__a       (    self	:Optional[Any])		->					Dict:
												return self.image_processor_tester.prepare_image_processor_dict()

						def 	__a       (    self	:Union[str, Any])		->					str:
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												self.assertTrue(hasattr(_lowercase   ,						'''do_resize'''))
												self.assertTrue(hasattr(_lowercase   ,						'''size'''))
												self.assertTrue(hasattr(_lowercase   ,						'''do_normalize'''))
												self.assertTrue(hasattr(_lowercase   ,						'''image_mean'''))
												self.assertTrue(hasattr(_lowercase   ,						'''image_std'''))
												self.assertTrue(hasattr(_lowercase   ,						'''do_convert_rgb'''))

						def 	__a       (    self	:Tuple)		->					int:
												pass

						def 	__a       (    self	:Optional[Any])		->					Union[str, Any]:
												# Initialize image_processor
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												# create random PIL images
												UpperCAmelCase_     							=     self.image_processor_tester.prepare_inputs(equal_resolution=_lowercase)
												for image in image_inputs:
																		self.assertIsInstance(_lowercase   ,						Image.Image)

												# Test not batched input
												UpperCAmelCase_     							=     image_processor(image_inputs[0]   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)

												# Test batched
												UpperCAmelCase_     							=     image_processor(_lowercase   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)

						def 	__a       (    self	:str)		->					int:
												# Initialize image_processor
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												# create random numpy tensors
												UpperCAmelCase_     							=     self.image_processor_tester.prepare_inputs(equal_resolution=_lowercase   ,						numpify=_lowercase)
												for image in image_inputs:
																		self.assertIsInstance(_lowercase   ,						np.ndarray)

												# Test not batched input
												UpperCAmelCase_     							=     image_processor(image_inputs[0]   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)

												# Test batched
												UpperCAmelCase_     							=     image_processor(_lowercase   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)




						def 	__a       (    self	:Optional[Any])		->					str:
												# Initialize image_processor
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												# create random PyTorch tensors
												UpperCAmelCase_     							=     self.image_processor_tester.prepare_inputs(equal_resolution=_lowercase   ,						torchify=_lowercase)
												for image in image_inputs:
																		self.assertIsInstance(_lowercase   ,						torch.Tensor)

												# Test not batched input
												UpperCAmelCase_     							=     image_processor(image_inputs[0]   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)

												# Test batched
												UpperCAmelCase_     							=     image_processor(_lowercase   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)







@require_torch
@require_vision
class 							a_  (		_snake_case					, unittest.TestCase				):
						UpperCamelCase__      :						Dict				       =BlipImageProcessor if is_vision_available() else None

						def 	__a       (    self	:Tuple)		->					Dict:
												UpperCAmelCase_     							=     BlipImageProcessingTester(self   ,						num_channels=4)
												UpperCAmelCase_     							=     3

						@property
						def 	__a       (    self	:str)		->					Dict:
												return self.image_processor_tester.prepare_image_processor_dict()

						def 	__a       (    self	:Any)		->					int:
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												self.assertTrue(hasattr(_lowercase   ,						'''do_resize'''))
												self.assertTrue(hasattr(_lowercase   ,						'''size'''))
												self.assertTrue(hasattr(_lowercase   ,						'''do_normalize'''))
												self.assertTrue(hasattr(_lowercase   ,						'''image_mean'''))
												self.assertTrue(hasattr(_lowercase   ,						'''image_std'''))
												self.assertTrue(hasattr(_lowercase   ,						'''do_convert_rgb'''))

						def 	__a       (    self	:Optional[Any])		->					Optional[Any]:
												pass




						def 	__a       (    self	:Dict)		->					str:
												# Initialize image_processor
												UpperCAmelCase_     							=     self.image_processing_class(**self.image_processor_dict)
												# create random PIL images
												UpperCAmelCase_     							=     self.image_processor_tester.prepare_inputs(equal_resolution=_lowercase)
												for image in image_inputs:
																		self.assertIsInstance(_lowercase   ,						Image.Image)

												# Test not batched input
												UpperCAmelCase_     							=     image_processor(image_inputs[0]   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        1,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)

												# Test batched
												UpperCAmelCase_     							=     image_processor(_lowercase   ,						return_tensors='''pt''').pixel_values
												self.assertEqual(
												    encoded_images.shape   ,						(
												        self.image_processor_tester.batch_size,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size['''height'''],
												        self.image_processor_tester.size['''width'''],
												    )   ,						)








def 						UpperCamelCase_(			snake_case__:  list   )       -> list:
 UpperCAmelCase__							=				len(snake_case__   )

 # Set the gap value to be decreased by a factor of 1.3
 # after each iteration
 UpperCAmelCase__							=				1.3

 # Continue sorting until the gap is 1
 while gap > 1:
  # Decrease the gap value
  UpperCAmelCase__							=				int(gap / shrink   )

  # Sort the elements using insertion sort
  for i in range(snake_case__  ,    len(snake_case__   )   ):
   UpperCAmelCase__							=				collection[i]
   UpperCAmelCase__							=				i
   while j >= gap and collection[j - gap] > temp:
    UpperCAmelCase__							=				collection[j - gap]
    j -= gap
   UpperCAmelCase__							=				temp

 return collection


if __name__ == "__main__":
 import doctest

 doctest.testmod()



