






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 CLIPImageProcessor



class  __UpperCAmelCase						(unittest.TestCase       ):







			def __init__(      self:    Optional[Any] ,      UpperCAmelCase_:    Any ,      UpperCAmelCase_:    Optional[Any]=7 ,      UpperCAmelCase_:    Optional[int]=3 ,      UpperCAmelCase_:    Any=18 ,      UpperCAmelCase_:    int=30 ,      UpperCAmelCase_:    int=400 ,      UpperCAmelCase_:    str=True ,      UpperCAmelCase_:    Optional[Any]=None ,      UpperCAmelCase_:    Union[str, Any]=True ,      UpperCAmelCase_:    Optional[Any]=None ,      UpperCAmelCase_:    str=True ,      UpperCAmelCase_:    int=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73] ,      UpperCAmelCase_:    Optional[int]=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11] ,      UpperCAmelCase_:    Dict=True ,      ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    size if size is not None else {"""shortest_edge""": 20}
									_SCREAMING_SNAKE_CASE       =    crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
									_SCREAMING_SNAKE_CASE       =    parent
									_SCREAMING_SNAKE_CASE       =    batch_size
									_SCREAMING_SNAKE_CASE       =    num_channels
									_SCREAMING_SNAKE_CASE       =    image_size
									_SCREAMING_SNAKE_CASE       =    min_resolution
									_SCREAMING_SNAKE_CASE       =    max_resolution
									_SCREAMING_SNAKE_CASE       =    do_resize
									_SCREAMING_SNAKE_CASE       =    size
									_SCREAMING_SNAKE_CASE       =    do_center_crop
									_SCREAMING_SNAKE_CASE       =    crop_size
									_SCREAMING_SNAKE_CASE       =    do_normalize
									_SCREAMING_SNAKE_CASE       =    image_mean
									_SCREAMING_SNAKE_CASE       =    image_std
									_SCREAMING_SNAKE_CASE       =    do_convert_rgb







			def 				UpperCamelCase (      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,
									    "do_convert_rgb": self.do_convert_rgb,
									}







			def 				UpperCamelCase (      self:    Tuple ,      UpperCAmelCase_:    Optional[int]=False ,      UpperCAmelCase_:    Tuple=False ,      UpperCAmelCase_:    int=False	):







									'''simple docstring'''




									assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

									if equal_resolution:
															_SCREAMING_SNAKE_CASE       =    []
															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:
															_SCREAMING_SNAKE_CASE       =    []
															for i in range(self.batch_size	):
																					_SCREAMING_SNAKE_CASE       =    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
															_SCREAMING_SNAKE_CASE       =    [Image.fromarray(np.moveaxis(_lowerCamelCase ,      0 ,      -1	)	) for x in image_inputs]

									if torchify:
															_SCREAMING_SNAKE_CASE       =    [torch.from_numpy(_lowerCamelCase	) for x in image_inputs]

									return image_inputs



@require_torch
@require_vision
class  __UpperCAmelCase						(__A			,unittest.TestCase       ):
			__snake_case							: Dict							=				CLIPImageProcessor if is_vision_available() else None







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    CLIPImageProcessingTester(self	)







			@property
			def 				UpperCamelCase (      self:    Optional[Any]	):







									'''simple docstring'''




									return self.image_processor_tester.prepare_image_processor_dict()







			def 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.image_processing_class(**self.image_processor_dict	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_resize"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """size"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_center_crop"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """center_crop"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_normalize"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """image_mean"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """image_std"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_convert_rgb"""	)	)







			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.image_processing_class.from_dict(self.image_processor_dict	)
									self.assertEqual(image_processor.size ,      {"""shortest_edge""": 20}	)
									self.assertEqual(image_processor.crop_size ,      {"""height""": 18, """width""": 18}	)

									_SCREAMING_SNAKE_CASE       =    self.image_processing_class.from_dict(self.image_processor_dict ,      size=42 ,      crop_size=84	)
									self.assertEqual(image_processor.size ,      {"""shortest_edge""": 42}	)
									self.assertEqual(image_processor.crop_size ,      {"""height""": 84, """width""": 84}	)







			def 				UpperCamelCase (      self:    Dict	):







									'''simple docstring'''




									pass







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




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

									# Test not batched input
									_SCREAMING_SNAKE_CASE       =    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
									_SCREAMING_SNAKE_CASE       =    image_processing(_lowerCamelCase ,      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:    Any	):







									'''simple docstring'''




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

									# Test not batched input
									_SCREAMING_SNAKE_CASE       =    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
									_SCREAMING_SNAKE_CASE       =    image_processing(_lowerCamelCase ,      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:    int	):







									'''simple docstring'''




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

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



@require_torch
@require_vision
class  __UpperCAmelCase						(__A			,unittest.TestCase       ):
			__snake_case							: int							=				CLIPImageProcessor if is_vision_available() else None







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    CLIPImageProcessingTester(self ,      num_channels=4	)
									_SCREAMING_SNAKE_CASE       =    3







			@property
			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									return self.image_processor_tester.prepare_image_processor_dict()







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.image_processing_class(**self.image_processor_dict	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_resize"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """size"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_center_crop"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """center_crop"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_normalize"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """image_mean"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """image_std"""	)	)
									self.assertTrue(hasattr(_lowerCamelCase ,      """do_convert_rgb"""	)	)







			def 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									pass







			def 				UpperCamelCase (      self:    List[str]	):







									'''simple docstring'''




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

									# Test not batched input
									_SCREAMING_SNAKE_CASE       =    image_processing(image_inputs[0] ,      return_tensors="""pt"""	).pixel_values
									self.assertEqual(
									    encoded_images.shape ,      (
									        1,
									        self.expected_encoded_image_num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    ) ,      )

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






'''simple docstring'''





from ..utils import DummyObject, requires_backends


class 							_lowerCAmelCase	(  metaclass=__A							):


 """simple docstring"""

 lowerCamelCase									=     ['''torch''', '''librosa''']







 def __init__(      self					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    str:
    requires_backends(self					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Optional[int]:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )


class 							_lowerCAmelCase	(  metaclass=__A							):


 """simple docstring"""

 lowerCamelCase									=     ['''torch''', '''librosa''']







 def __init__(      self					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(self					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    str:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )
