
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 		__magic_name__				( unittest.TestCase					):


  """simple docstring"""





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

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


  def     _UpperCAmelCase  (					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 		__magic_name__				( _A						,unittest.TestCase					):


  """simple docstring"""





  _UpperCamelCase						 = DeiTImageProcessor if is_vision_available() else None
  _UpperCamelCase						 = True


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						DeiTImageProcessingTester(self		)


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


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						self.image_processing_class(**self.image_processor_dict		)
    self.assertTrue(hasattr(__A	,		'''do_resize'''		)		)
    self.assertTrue(hasattr(__A	,		'''size'''		)		)
    self.assertTrue(hasattr(__A	,		'''do_center_crop'''		)		)
    self.assertTrue(hasattr(__A	,		'''center_crop'''		)		)
    self.assertTrue(hasattr(__A	,		'''do_normalize'''		)		)
    self.assertTrue(hasattr(__A	,		'''image_mean'''		)		)
    self.assertTrue(hasattr(__A	,		'''image_std'''		)		)


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						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      =						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     _UpperCAmelCase  (					self		):
    pass


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						self.image_processing_class(**self.image_processor_dict		)
    # create random PIL images
    _lowerCamelCase      =						prepare_image_inputs(self.image_processor_tester	,		equal_resolution=__A		)
    for image in image_inputs:
      self.assertIsInstance(__A	,		Image.Image		)

    # Test not batched input
    _lowerCamelCase      =						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      =						image_processing(__A	,		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     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						self.image_processing_class(**self.image_processor_dict		)
    # create random numpy tensors
    _lowerCamelCase      =						prepare_image_inputs(self.image_processor_tester	,		equal_resolution=__A	,		numpify=__A		)
    for image in image_inputs:
      self.assertIsInstance(__A	,		np.ndarray		)

    # Test not batched input
    _lowerCamelCase      =						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      =						image_processing(__A	,		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     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						self.image_processing_class(**self.image_processor_dict		)
    # create random PyTorch tensors
    _lowerCamelCase      =						prepare_image_inputs(self.image_processor_tester	,		equal_resolution=__A	,		torchify=__A		)
    for image in image_inputs:
      self.assertIsInstance(__A	,		torch.Tensor		)

    # Test not batched input
    _lowerCamelCase      =						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      =						image_processing(__A	,		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'''],
        )	,		)









'''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      lowerCamelCase__     (     unittest.TestCase				):






	'''simple docstring'''

	def __init__(  self		:  List[str]   ,		__A		:  Any   ,		__A		:  Tuple=7   ,		__A		:  Dict=3   ,		__A		:  List[str]=18   ,		__A		:  Optional[int]=30   ,		__A		:  int=400   ,		__A		:  Union[str, Any]=True   ,		__A		:  Tuple=None   ,		__A		:  int=True   ,		__A		:  int=None   ,		__A		:  List[str]=True   ,		__A		:  Union[str, Any]=[0.5, 0.5, 0.5]   ,		__A		:  List[Any]=[0.5, 0.5, 0.5]   ,		)     ->			List[str]:




								'''simple docstring'''





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

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




	def      lowercase__							(  self		:  Tuple					)     ->			Optional[int]:




								'''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      lowerCamelCase__     (     _A,     unittest.TestCase				):






	'''simple docstring'''

	A__		=	DeiTImageProcessor if is_vision_available() else None
	A__		=	True




	def      lowercase__							(  self		:  List[Any]					)     ->			Dict:




								'''simple docstring'''





								lowerCAmelCase__  =   DeiTImageProcessingTester(self					)




	@property
	def      lowercase__							(  self		:  Any					)     ->			int:




								'''simple docstring'''





								return self.image_processor_tester.prepare_image_processor_dict()




	def      lowercase__							(  self		:  str					)     ->			Optional[Any]:




								'''simple docstring'''





								lowerCAmelCase__  =   self.image_processing_class(**self.image_processor_dict					)
								self.assertTrue(hasattr(__A   ,		"""do_resize"""					)					)
								self.assertTrue(hasattr(__A   ,		"""size"""					)					)
								self.assertTrue(hasattr(__A   ,		"""do_center_crop"""					)					)
								self.assertTrue(hasattr(__A   ,		"""center_crop"""					)					)
								self.assertTrue(hasattr(__A   ,		"""do_normalize"""					)					)
								self.assertTrue(hasattr(__A   ,		"""image_mean"""					)					)
								self.assertTrue(hasattr(__A   ,		"""image_std"""					)					)




	def      lowercase__							(  self		:  Optional[int]					)     ->			Optional[int]:




								'''simple docstring'''





								lowerCAmelCase__  =   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__  =   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      lowercase__							(  self		:  Optional[int]					)     ->			List[str]:




								'''simple docstring'''





								pass




	def      lowercase__							(  self		:  Dict					)     ->			Tuple:




								'''simple docstring'''





								lowerCAmelCase__  =   self.image_processing_class(**self.image_processor_dict					)
								# create random PIL images
								lowerCAmelCase__  =   prepare_image_inputs(self.image_processor_tester   ,		equal_resolution=__A					)
								for image in image_inputs:
															self.assertIsInstance(__A   ,		Image.Image					)

								# Test not batched input
								lowerCAmelCase__  =   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__  =   image_processing(__A   ,		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      lowercase__							(  self		:  List[Any]					)     ->			Optional[int]:




								'''simple docstring'''





								lowerCAmelCase__  =   self.image_processing_class(**self.image_processor_dict					)
								# create random numpy tensors
								lowerCAmelCase__  =   prepare_image_inputs(self.image_processor_tester   ,		equal_resolution=__A   ,		numpify=__A					)
								for image in image_inputs:
															self.assertIsInstance(__A   ,		np.ndarray					)

								# Test not batched input
								lowerCAmelCase__  =   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__  =   image_processing(__A   ,		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      lowercase__							(  self		:  List[str]					)     ->			Tuple:




								'''simple docstring'''





								lowerCAmelCase__  =   self.image_processing_class(**self.image_processor_dict					)
								# create random PyTorch tensors
								lowerCAmelCase__  =   prepare_image_inputs(self.image_processor_tester   ,		equal_resolution=__A   ,		torchify=__A					)
								for image in image_inputs:
															self.assertIsInstance(__A   ,		torch.Tensor					)

								# Test not batched input
								lowerCAmelCase__  =   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__  =   image_processing(__A   ,		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"""],
								    )   ,		)





