'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				list  ):



     """simple docstring"""





     UpperCAmelCase_				:  Optional[int]  = len(lowerCamelCase_  )

     # Set the gap value to be decreased by a factor of 1.3
     # after each iteration
     UpperCAmelCase_				:  Optional[Any]  = 1.3

     # Continue sorting until the gap is 1
     while gap > 1:
          # Decrease the gap value
          UpperCAmelCase_				:  Optional[Any]  = int(gap / shrink  )

          # Sort the elements using insertion sort
          for i in range(lowerCamelCase_      ,	len(lowerCamelCase_  )  ):
               UpperCAmelCase_				:  Optional[int]  = collection[i]
               UpperCAmelCase_				:  Tuple  = i
               while j >= gap and collection[j - gap] > temp:
                    UpperCAmelCase_				:  Tuple  = collection[j - gap]
                    j -= gap
               UpperCAmelCase_				:  Optional[int]  = temp

     return collection


if __name__ == "__main__":
 import doctest

 doctest.testmod()








"""simple docstring"""







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 DeiTImageProcessor




class 					A__			(      unittest.TestCase):

		def __init__( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE=7			,						_SCREAMING_SNAKE_CASE=3			,						_SCREAMING_SNAKE_CASE=18			,						_SCREAMING_SNAKE_CASE=30			,						_SCREAMING_SNAKE_CASE=4_00			,						_SCREAMING_SNAKE_CASE=True			,						_SCREAMING_SNAKE_CASE=None			,						_SCREAMING_SNAKE_CASE=True			,						_SCREAMING_SNAKE_CASE=None			,						_SCREAMING_SNAKE_CASE=True			,						_SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]			,						_SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]			,						):
			__lowerCAmelCase     :		List[str]		     = size if size is not None else {'height': 20, 'width': 20}
			__lowerCAmelCase     :		List[str]		     = crop_size if crop_size is not None else {'height': 18, 'width': 18}

			__lowerCAmelCase     :		Any		     = parent
			__lowerCAmelCase     :		Optional[Any]		     = batch_size
			__lowerCAmelCase     :		Any		     = num_channels
			__lowerCAmelCase     :		Dict		     = image_size
			__lowerCAmelCase     :		Tuple		     = min_resolution
			__lowerCAmelCase     :		Union[str, Any]		     = max_resolution
			__lowerCAmelCase     :		Optional[int]		     = do_resize
			__lowerCAmelCase     :		Any		     = size
			__lowerCAmelCase     :		Union[str, Any]		     = do_center_crop
			__lowerCAmelCase     :		List[Any]		     = crop_size
			__lowerCAmelCase     :		Optional[int]		     = do_normalize
			__lowerCAmelCase     :		int		     = image_mean
			__lowerCAmelCase     :		Tuple		     = image_std







		def 				__lowerCamelCase				( self					):
			return {
			    "do_resize": self.do_resize,
			    "size": self.size,
			    "do_center_crop": self.do_center_crop,
			    "crop_size": self.crop_size,
			    "do_normalize": self.do_normalize,
			    "image_mean": self.image_mean,
			    "image_std": self.image_std,
			}




@require_torch
@require_vision
class 					A__			(      _lowerCamelCase			,	unittest.TestCase):
		A_		:			List[str]							  =      DeiTImageProcessor if is_vision_available() else None
		A_		:			int							  =      True

		def 				__lowerCamelCase				( self					):
			__lowerCAmelCase     :		Optional[int]		     = DeiTImageProcessingTester(self					)

		@property
		def 				__lowerCamelCase				( self					):
			return self.image_processor_tester.prepare_image_processor_dict()

		def 				__lowerCamelCase				( self					):
			__lowerCAmelCase     :		Any		     = self.image_processing_class(**self.image_processor_dict					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'do_resize'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'size'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'do_center_crop'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'center_crop'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'do_normalize'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'image_mean'					)					)
			self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE			,						'image_std'					)					)

		def 				__lowerCamelCase				( self					):
			__lowerCAmelCase     :		Tuple		     = self.image_processing_class.from_dict(self.image_processor_dict					)
			self.assertEqual(image_processor.size			,						{'height': 20, 'width': 20}					)
			self.assertEqual(image_processor.crop_size			,						{'height': 18, 'width': 18}					)

			__lowerCAmelCase     :		str		     = self.image_processing_class.from_dict(self.image_processor_dict			,						size=42			,						crop_size=84					)
			self.assertEqual(image_processor.size			,						{'height': 42, 'width': 42}					)
			self.assertEqual(image_processor.crop_size			,						{'height': 84, 'width': 84}					)

		def 				__lowerCamelCase				( self					):
			pass

		def 				__lowerCamelCase				( self					):
			# Initialize image_processing
			__lowerCAmelCase     :		Dict		     = self.image_processing_class(**self.image_processor_dict					)
			# create random PIL images
			__lowerCAmelCase     :		List[str]		     = prepare_image_inputs(self.image_processor_tester			,						equal_resolution=_SCREAMING_SNAKE_CASE					)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE			,						Image.Image					)

			# Test not batched input
			__lowerCAmelCase     :		Dict		     = image_processing(image_inputs[0]			,						return_tensors='pt'					).pixel_values
			self.assertEqual(
			    encoded_images.shape			,						(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)

			# Test batched
			__lowerCAmelCase     :		int		     = image_processing(_SCREAMING_SNAKE_CASE			,						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.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)

		def 				__lowerCamelCase				( self					):
			# Initialize image_processing
			__lowerCAmelCase     :		Optional[int]		     = self.image_processing_class(**self.image_processor_dict					)
			# create random numpy tensors
			__lowerCAmelCase     :		List[str]		     = prepare_image_inputs(self.image_processor_tester			,						equal_resolution=_SCREAMING_SNAKE_CASE			,						numpify=_SCREAMING_SNAKE_CASE					)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE			,						np.ndarray					)

			# Test not batched input
			__lowerCAmelCase     :		str		     = image_processing(image_inputs[0]			,						return_tensors='pt'					).pixel_values
			self.assertEqual(
			    encoded_images.shape			,						(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)

			# Test batched
			__lowerCAmelCase     :		Dict		     = image_processing(_SCREAMING_SNAKE_CASE			,						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.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)







		def 				__lowerCamelCase				( self					):
			# Initialize image_processing
			__lowerCAmelCase     :		Union[str, Any]		     = self.image_processing_class(**self.image_processor_dict					)
			# create random PyTorch tensors
			__lowerCAmelCase     :		List[str]		     = prepare_image_inputs(self.image_processor_tester			,						equal_resolution=_SCREAMING_SNAKE_CASE			,						torchify=_SCREAMING_SNAKE_CASE					)
			for image in image_inputs:
				self.assertIsInstance(_SCREAMING_SNAKE_CASE			,						torch.Tensor					)

			# Test not batched input
			__lowerCAmelCase     :		Union[str, Any]		     = image_processing(image_inputs[0]			,						return_tensors='pt'					).pixel_values
			self.assertEqual(
			    encoded_images.shape			,						(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)

			# Test batched
			__lowerCAmelCase     :		Optional[int]		     = image_processing(_SCREAMING_SNAKE_CASE			,						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.crop_size['height'],
			        self.image_processor_tester.crop_size['width'],
			    )			,						)