



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				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	Optional[int]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=7	,						__SCREAMING_SNAKE_CASE				:	Dict=3	,						__SCREAMING_SNAKE_CASE				:	str=18	,						__SCREAMING_SNAKE_CASE				:	Optional[int]=30	,						__SCREAMING_SNAKE_CASE				:	List[str]=400	,						__SCREAMING_SNAKE_CASE				:	List[Any]=True	,						__SCREAMING_SNAKE_CASE				:	List[str]=None	,						__SCREAMING_SNAKE_CASE				:	str=True	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=None	,						__SCREAMING_SNAKE_CASE				:	Dict=True	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=[0.5, 0.5, 0.5]	,						__SCREAMING_SNAKE_CASE				:	List[str]=[0.5, 0.5, 0.5]	,						):


           '''simple docstring'''

           __a					=							size if size is not None else {'''height''': 20, '''width''': 20}
           __a					=							crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}

           __a					=							parent
           __a					=							batch_size
           __a					=							num_channels
           __a					=							image_size
           __a					=							min_resolution
           __a					=							max_resolution
           __a					=							do_resize
           __a					=							size
           __a					=							do_center_crop
           __a					=							crop_size
           __a					=							do_normalize
           __a					=							image_mean
           __a					=							image_std





       def 						_lowerCamelCase     (						self				:	Dict):


           '''simple docstring'''

           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			(      __UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       Union[str, Any]		   =		DeiTImageProcessor if is_vision_available() else None
       UpperCamelCase__    :       str		   =		True



       def 						_lowerCamelCase     (						self				:	Dict):


           '''simple docstring'''

           __a					=							DeiTImageProcessingTester(self)



       @property
       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()



       def 						_lowerCamelCase     (						self				:	Dict):


           '''simple docstring'''

           __a					=							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				:	Tuple):


           '''simple docstring'''

           __a					=							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})

           __a					=							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				:	Any):


           '''simple docstring'''

           pass



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							self.image_processing_class(**self.image_processor_dict)
           # create random PIL images
           __a					=							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
           __a					=							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
           __a					=							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				:	Tuple):


           '''simple docstring'''

           __a					=							self.image_processing_class(**self.image_processor_dict)
           # create random numpy tensors
           __a					=							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
           __a					=							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
           __a					=							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				:	Tuple):


           '''simple docstring'''

           __a					=							self.image_processing_class(**self.image_processor_dict)
           # create random PyTorch tensors
           __a					=							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
           __a					=							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
           __a					=							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 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5) + 32  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) + 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5) + 4_91.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) - 32) * 5 / 9  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(((float(_UpperCAmelCase							) - 32) * 5 / 9) + 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) + 4_59.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) - 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(((float(_UpperCAmelCase							) - 2_73.15) * 9 / 5) + 32  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) - 4_91.67) * 5 / 9  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) - 4_59.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 5 / 9)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 1.25 + 2_73.15)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 2.25 + 32)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 1.25)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 2.25 + 32 + 4_59.67)  ,					_UpperCAmelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()





