






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 	snake_case__ (							unittest.TestCase				):
	def __init__(    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=7      ,       lowerCAmelCase__=3      ,       lowerCAmelCase__=18      ,       lowerCAmelCase__=30      ,       lowerCAmelCase__=4_00      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]      ,       lowerCAmelCase__=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]      ,       lowerCAmelCase__=True      ,       )							->				List[str]:
							__magic_name__      :       Tuple       						= size if size is not None else {'''height''': 2_24, '''width''': 2_24}
							__magic_name__      :       List[str]       						= crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
							__magic_name__      :       List[Any]       						= parent
							__magic_name__      :       List[str]       						= batch_size
							__magic_name__      :       str       						= num_channels
							__magic_name__      :       int       						= image_size
							__magic_name__      :       Union[str, Any]       						= min_resolution
							__magic_name__      :       str       						= max_resolution
							__magic_name__      :       Tuple       						= do_resize
							__magic_name__      :       Union[str, Any]       						= size
							__magic_name__      :       Any       						= do_center_crop
							__magic_name__      :       int       						= crop_size
							__magic_name__      :       Any       						= do_normalize
							__magic_name__      :       str       						= image_mean
							__magic_name__      :       List[Any]       						= image_std
							__magic_name__      :       Dict       						= do_convert_rgb
	def       __magic_name__    (    self			)							->				Any:
							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       __magic_name__    (    self      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=False			)							->				Optional[int]:
							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

							if equal_resolution:
													__magic_name__      :       Union[str, Any]       						= []
													for i in range(self.batch_size			):
																			image_inputs.append(
																			    np.random.randint(
																			        2_55      ,       size=(self.num_channels, self.max_resolution, self.max_resolution)      ,       dtype=np.uinta			)			)
							else:
													__magic_name__      :       Any       						= []
													for i in range(self.batch_size			):
																			__magic_name__      :       Optional[Any]       						= np.random.choice(np.arange(self.min_resolution      ,       self.max_resolution			)      ,       2			)
																			image_inputs.append(np.random.randint(2_55      ,       size=(self.num_channels, width, height)      ,       dtype=np.uinta			)			)

							if not numpify and not torchify:
													# PIL expects the channel dimension as last dimension
													__magic_name__      :       List[Any]       						= [Image.fromarray(np.moveaxis(lowerCAmelCase__      ,       0      ,       -1			)			) for x in image_inputs]

							if torchify:
													__magic_name__      :       List[str]       						= [torch.from_numpy(lowerCAmelCase__			) for x in image_inputs]

							return image_inputs





@require_torch
@require_vision
class 	snake_case__ (							_lowerCAmelCase						,  unittest.TestCase				):
	lowercase__						:					List[str]											=   ChineseCLIPImageProcessor if is_vision_available() else None
	def       __magic_name__    (    self			)							->				List[str]:
							__magic_name__      :       Any       						= ChineseCLIPImageProcessingTester(self      ,       do_center_crop=lowerCAmelCase__			)
	@property
	def       __magic_name__    (    self			)							->				List[Any]:
							return self.image_processor_tester.prepare_image_processor_dict()
	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       Optional[Any]       						= 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       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Any       						= self.image_processing_class.from_dict(self.image_processor_dict			)
							self.assertEqual(image_processor.size      ,       {"""height""": 2_24, """width""": 2_24}			)
							self.assertEqual(image_processor.crop_size      ,       {"""height""": 18, """width""": 18}			)

							__magic_name__      :       Dict       						= 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       __magic_name__    (    self			)							->				Tuple:
							pass
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							# Initialize image_processing
							__magic_name__      :       Optional[int]       						= self.image_processing_class(**self.image_processor_dict			)
							# create random PIL images
							__magic_name__      :       Union[str, Any]       						= self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__			)
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__      ,       Image.Image			)

							# Test not batched input
							__magic_name__      :       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
							__magic_name__      :       Any       						= 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       __magic_name__    (    self			)							->				str:
							# Initialize image_processing
							__magic_name__      :       str       						= self.image_processing_class(**self.image_processor_dict			)
							# create random numpy tensors
							__magic_name__      :       Any       						= 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
							__magic_name__      :       Tuple       						= 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
							__magic_name__      :       Dict       						= 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       __magic_name__    (    self			)							->				Tuple:
							# Initialize image_processing
							__magic_name__      :       Tuple       						= self.image_processing_class(**self.image_processor_dict			)
							# create random PyTorch tensors
							__magic_name__      :       List[str]       						= 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
							__magic_name__      :       List[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
							__magic_name__      :       List[str]       						= 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 	snake_case__ (							_lowerCAmelCase						,  unittest.TestCase				):
	lowercase__						:					Union[str, Any]											=   ChineseCLIPImageProcessor if is_vision_available() else None
	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       Any       						= ChineseCLIPImageProcessingTester(self      ,       num_channels=4      ,       do_center_crop=lowerCAmelCase__			)
							__magic_name__      :       List[Any]       						= 3
	@property
	def       __magic_name__    (    self			)							->				Tuple:
							return self.image_processor_tester.prepare_image_processor_dict()
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       List[str]       						= 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       __magic_name__    (    self			)							->				int:
							pass







	def       __magic_name__    (    self			)							->				Optional[Any]:
							# Initialize image_processing
							__magic_name__      :       Optional[int]       						= self.image_processing_class(**self.image_processor_dict			)
							# create random PIL images
							__magic_name__      :       str       						= self.image_processor_tester.prepare_inputs(equal_resolution=lowerCAmelCase__			)
							for image in image_inputs:
													self.assertIsInstance(lowerCAmelCase__      ,       Image.Image			)

							# Test not batched input
							__magic_name__      :       str       						= 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
							__magic_name__      :       Optional[int]       						= 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"""],
							    )      ,       )








__magic_name__:					List[Any]							=     "\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

__magic_name__:					Dict							=     [{"type": "code", "content": INSTALL_CONTENT}]
__magic_name__:					Optional[Any]							=     {
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}
