
'''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


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import CLIPImageProcessor





class 			A							(       unittest.TestCase				):



			def __init__(					self       ,     lowerCamelCase__       ,     lowerCamelCase__=7       ,     lowerCamelCase__=3       ,     lowerCamelCase__=18       ,     lowerCamelCase__=30       ,     lowerCamelCase__=400       ,     lowerCamelCase__=True       ,     lowerCamelCase__=None       ,     lowerCamelCase__=True       ,     lowerCamelCase__=None       ,     lowerCamelCase__=True       ,     lowerCamelCase__=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]       ,     lowerCamelCase__=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]       ,     lowerCamelCase__=True       ,     )			->		Optional[int]:




									'''simple docstring'''



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



			def A__ (					self       )			->		str:




									'''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       ,     lowerCamelCase__=False       ,     lowerCamelCase__=False       ,     lowerCamelCase__=False       )			->		Any:




									'''simple docstring'''



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

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

									if torchify:
															lowercase__							 =       [torch.from_numpy(lowerCamelCase__       ) for x in image_inputs]

									return image_inputs





@require_torch
@require_vision
class 			A							(       __UpperCAmelCase		,						unittest.TestCase				):
			lowerCamelCase							:							Any       		=  CLIPImageProcessor if is_vision_available() else None



			def A__ (					self       )			->		int:




									'''simple docstring'''



									lowercase__							 =       CLIPImageProcessingTester(self       )



			@property
			def A__ (					self       )			->		Optional[Any]:




									'''simple docstring'''



									return self.image_processor_tester.prepare_image_processor_dict()



			def A__ (					self       )			->		Tuple:




									'''simple docstring'''



									lowercase__							 =       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 A__ (					self       )			->		Optional[int]:




									'''simple docstring'''



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

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




									'''simple docstring'''



									pass



			def A__ (					self       )			->		Any:




									'''simple docstring'''



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

									# Test not batched input
									lowercase__							 =       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
									lowercase__							 =       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 A__ (					self       )			->		Tuple:




									'''simple docstring'''



									lowercase__							 =       self.image_processing_class(**self.image_processor_dict       )
									# create random numpy tensors
									lowercase__							 =       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
									lowercase__							 =       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
									lowercase__							 =       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 A__ (					self       )			->		Union[str, Any]:




									'''simple docstring'''



									lowercase__							 =       self.image_processing_class(**self.image_processor_dict       )
									# create random PyTorch tensors
									lowercase__							 =       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
									lowercase__							 =       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
									lowercase__							 =       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 			A							(       __UpperCAmelCase		,						unittest.TestCase				):
			lowerCamelCase							:							Optional[Any]       		=  CLIPImageProcessor if is_vision_available() else None



			def A__ (					self       )			->		Union[str, Any]:




									'''simple docstring'''



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



			@property
			def A__ (					self       )			->		Union[str, Any]:




									'''simple docstring'''



									return self.image_processor_tester.prepare_image_processor_dict()



			def A__ (					self       )			->		Tuple:




									'''simple docstring'''



									lowercase__							 =       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 A__ (					self       )			->		Any:




									'''simple docstring'''



									pass



			def A__ (					self       )			->		Tuple:




									'''simple docstring'''



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

									# Test not batched input
									lowercase__							 =       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
									lowercase__							 =       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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__A          =    {"configuration_detr": ["DETR_PRETRAINED_CONFIG_ARCHIVE_MAP", "DetrConfig", "DetrOnnxConfig"]}

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A          =    ["DetrFeatureExtractor"]
				__A          =    ["DetrImageProcessor"]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A          =    [
				    "DETR_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "DetrForObjectDetection",
				    "DetrForSegmentation",
				    "DetrModel",
				    "DetrPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_detr import DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DetrConfig, DetrOnnxConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_detr import DetrFeatureExtractor
								from .image_processing_detr import DetrImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_detr import (
								    DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DetrForObjectDetection,
								    DetrForSegmentation,
								    DetrModel,
								    DetrPreTrainedModel,
								)

else:
				import sys

				__A          =    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






