
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 OwlViTImageProcessor





class      _lowerCAmelCase (     unittest.TestCase	):




				def __init__( self    ,    _UpperCamelCase    ,    _UpperCamelCase=7    ,    _UpperCamelCase=3    ,    _UpperCamelCase=18    ,    _UpperCamelCase=30    ,    _UpperCamelCase=400    ,    _UpperCamelCase=True    ,    _UpperCamelCase=None    ,    _UpperCamelCase=True    ,    _UpperCamelCase=None    ,    _UpperCamelCase=True    ,    _UpperCamelCase=[0.48145466, 0.4578275, 0.40821073]    ,    _UpperCamelCase=[0.26862954, 0.26130258, 0.27577711]    ,    _UpperCamelCase=True    ,    )    ->				Tuple:
							lowerCAmelCase_      =     parent
							lowerCAmelCase_      =     batch_size
							lowerCAmelCase_      =     num_channels
							lowerCAmelCase_      =     image_size
							lowerCAmelCase_      =     min_resolution
							lowerCAmelCase_      =     max_resolution
							lowerCAmelCase_      =     do_resize
							lowerCAmelCase_      =     size if size is not None else {"height": 18, "width": 18}
							lowerCAmelCase_      =     do_center_crop
							lowerCAmelCase_      =     crop_size if crop_size is not None else {"height": 18, "width": 18}
							lowerCAmelCase_      =     do_normalize
							lowerCAmelCase_      =     image_mean
							lowerCAmelCase_      =     image_std
							lowerCAmelCase_      =     do_convert_rgb




				def 					__a						( self					)    ->				Dict:
							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,
							}





@require_torch
@require_vision
class      _lowerCAmelCase (     __a ,				unittest.TestCase	):
				_lowercase      		=OwlViTImageProcessor if is_vision_available() else None




				def 					__a						( self					)    ->				Any:
							lowerCAmelCase_      =     OwlViTImageProcessingTester(self					)




				@property
				def 					__a						( self					)    ->				Tuple:
							return self.image_processor_tester.prepare_image_processor_dict()




				def 					__a						( self					)    ->				Optional[Any]:
							lowerCAmelCase_      =     self.image_processing_class(**self.image_processor_dict					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "do_resize"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "size"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "do_center_crop"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "center_crop"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "do_normalize"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "image_mean"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "image_std"					)					)
							self.assertTrue(hasattr(_UpperCamelCase    ,    "do_convert_rgb"					)					)




				def 					__a						( self					)    ->				Union[str, Any]:
							lowerCAmelCase_      =     self.image_processing_class.from_dict(self.image_processor_dict					)
							self.assertEqual(image_processor.size    ,    {"height": 18, "width": 18}					)
							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 					__a						( self					)    ->				Union[str, Any]:
							# Initialize image_processing
							lowerCAmelCase_      =     self.image_processing_class(**self.image_processor_dict					)
							# create random PIL images
							lowerCAmelCase_      =     prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_UpperCamelCase					)

							for image in image_inputs:
										self.assertIsInstance(_UpperCamelCase    ,    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(_UpperCamelCase    ,    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					)    ->				Optional[int]:
							# Initialize image_processing
							lowerCAmelCase_      =     self.image_processing_class(**self.image_processor_dict					)
							# create random numpy tensors
							lowerCAmelCase_      =     prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_UpperCamelCase    ,    numpify=_UpperCamelCase					)
							for image in image_inputs:
										self.assertIsInstance(_UpperCamelCase    ,    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(_UpperCamelCase    ,    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[Any]:
							# Initialize image_processing
							lowerCAmelCase_      =     self.image_processing_class(**self.image_processor_dict					)
							# create random PyTorch tensors
							lowerCAmelCase_      =     prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_UpperCamelCase    ,    torchify=_UpperCamelCase					)
							for image in image_inputs:
										self.assertIsInstance(_UpperCamelCase    ,    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(_UpperCamelCase    ,    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"],
							    )    ,    )





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A       =					{"configuration_nat": ["NAT_PRETRAINED_CONFIG_ARCHIVE_MAP", "NatConfig"]}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A       =					[
			    "NAT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "NatForImageClassification",
			    "NatModel",
			    "NatPreTrainedModel",
			    "NatBackbone",
			]

if TYPE_CHECKING:
			from .configuration_nat import NAT_PRETRAINED_CONFIG_ARCHIVE_MAP, NatConfig

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_nat import (
						    NAT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    NatBackbone,
						    NatForImageClassification,
						    NatModel,
						    NatPreTrainedModel,
						)

else:
			import sys

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



