
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 ChineseCLIPImageProcessor




class    SCREAMING_SNAKE_CASE__     (	unittest.TestCase					):





	'''simple docstring'''



	def __init__(  self	:    Union[str, Any]			,  lowercase	:    Any			,  lowercase	:    Dict=7			,  lowercase	:    List[str]=3			,  lowercase	:    List[str]=18			,  lowercase	:    List[Any]=30			,  lowercase	:    List[str]=400			,  lowercase	:    Union[str, Any]=True			,  lowercase	:    Tuple=None			,  lowercase	:    Optional[int]=True			,  lowercase	:    Dict=None			,  lowercase	:    int=True			,  lowercase	:    Any=[0.48145466, 0.4578275, 0.40821073]			,  lowercase	:    List[str]=[0.26862954, 0.26130258, 0.27577711]			,  lowercase	:    List[Any]=True			,  ):


				'''simple docstring'''


				_snake_case		=			size if size is not None else {'height': 224, 'width': 224}
				_snake_case		=			crop_size if crop_size is not None else {'height': 18, 'width': 18}
				_snake_case		=			parent
				_snake_case		=			batch_size
				_snake_case		=			num_channels
				_snake_case		=			image_size
				_snake_case		=			min_resolution
				_snake_case		=			max_resolution
				_snake_case		=			do_resize
				_snake_case		=			size
				_snake_case		=			do_center_crop
				_snake_case		=			crop_size
				_snake_case		=			do_normalize
				_snake_case		=			image_mean
				_snake_case		=			image_std
				_snake_case		=			do_convert_rgb



	def  A							(  self	:    List[Any]	):


				'''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  A							(  self	:    str			,  lowercase	:    Dict=False			,  lowercase	:    Dict=False			,  lowercase	:    List[str]=False	):


				'''simple docstring'''


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

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

				if torchify:
							_snake_case		=			[torch.from_numpy(lowercase	) for x in image_inputs]

				return image_inputs




@require_torch
@require_vision
class    SCREAMING_SNAKE_CASE__     (	UpperCAmelCase							,unittest.TestCase					):





	'''simple docstring'''



	_UpperCAmelCase       :		int       =					ChineseCLIPImageProcessor if is_vision_available() else None



	def  A							(  self	:    Dict	):


				'''simple docstring'''


				_snake_case		=			ChineseCLIPImageProcessingTester(self			,  do_center_crop=lowercase	)



	@property
	def  A							(  self	:    Dict	):


				'''simple docstring'''


				return self.image_processor_tester.prepare_image_processor_dict()



	def  A							(  self	:    int	):


				'''simple docstring'''


				_snake_case		=			self.image_processing_class(**self.image_processor_dict	)
				self.assertTrue(hasattr(lowercase			,  'do_resize'	)	)
				self.assertTrue(hasattr(lowercase			,  'size'	)	)
				self.assertTrue(hasattr(lowercase			,  'do_center_crop'	)	)
				self.assertTrue(hasattr(lowercase			,  'center_crop'	)	)
				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	:    int	):


				'''simple docstring'''


				_snake_case		=			self.image_processing_class.from_dict(self.image_processor_dict	)
				self.assertEqual(image_processor.size			,  {'height': 224, 'width': 224}	)
				self.assertEqual(image_processor.crop_size			,  {'height': 18, 'width': 18}	)

				_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  A							(  self	:    Optional[Any]	):


				'''simple docstring'''


				pass



	def  A							(  self	:    int	):


				'''simple docstring'''


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

				# Test not batched input
				_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
				_snake_case		=			image_processing(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.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )			,  )



	def  A							(  self	:    List[str]	):


				'''simple docstring'''


				_snake_case		=			self.image_processing_class(**self.image_processor_dict	)
				# create random numpy tensors
				_snake_case		=			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
				_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
				_snake_case		=			image_processing(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.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )			,  )





	def  A							(  self	:    Union[str, Any]	):


				'''simple docstring'''


				_snake_case		=			self.image_processing_class(**self.image_processor_dict	)
				# create random PyTorch tensors
				_snake_case		=			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
				_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
				_snake_case		=			image_processing(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.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )			,  )




@require_torch
@require_vision
class    SCREAMING_SNAKE_CASE__     (	UpperCAmelCase							,unittest.TestCase					):





	'''simple docstring'''



	_UpperCAmelCase       :		Tuple       =					ChineseCLIPImageProcessor if is_vision_available() else None



	def  A							(  self	:    str	):


				'''simple docstring'''


				_snake_case		=			ChineseCLIPImageProcessingTester(self			,  num_channels=4			,  do_center_crop=lowercase	)
				_snake_case		=			3



	@property
	def  A							(  self	:    Union[str, Any]	):


				'''simple docstring'''


				return self.image_processor_tester.prepare_image_processor_dict()



	def  A							(  self	:    int	):


				'''simple docstring'''


				_snake_case		=			self.image_processing_class(**self.image_processor_dict	)
				self.assertTrue(hasattr(lowercase			,  'do_resize'	)	)
				self.assertTrue(hasattr(lowercase			,  'size'	)	)
				self.assertTrue(hasattr(lowercase			,  'do_center_crop'	)	)
				self.assertTrue(hasattr(lowercase			,  'center_crop'	)	)
				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[int]	):


				'''simple docstring'''


				pass





	def  A							(  self	:    str	):


				'''simple docstring'''


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

				# Test not batched input
				_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
				_snake_case		=			image_processing(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.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )			,  )

import warnings

from ...utils import logging
from .image_processing_chinese_clip import ChineseCLIPImageProcessor


_lowerCamelCase       :				Dict       =			logging.get_logger(__name__)




class    SCREAMING_SNAKE_CASE__     (	UpperCAmelCase					):





	'''simple docstring'''



	def __init__(  self	:    Tuple			,  *lowercase	:    Optional[int]			,  **lowercase	:    Any	):


				'''simple docstring'''


				warnings.warn(
				    'The class ChineseCLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
				    ' Please use ChineseCLIPImageProcessor instead.'			,  lowercase			,  )
				super().__init__(*lowercase			,  **lowercase	)