



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 EfficientNetImageProcessor





class       __lowerCAmelCase				(  unittest.TestCase ):




				def __init__(							self		,       _snake_case		,       _snake_case=13		,       _snake_case=3		,       _snake_case=18		,       _snake_case=30		,       _snake_case=400		,       _snake_case=True		,       _snake_case=None		,       _snake_case=True		,       _snake_case=[0.5, 0.5, 0.5]		,       _snake_case=[0.5, 0.5, 0.5]		,       ):



									"""simple docstring"""





									_lowerCAmelCase      			=					size if size is not None else {"""height""": 18, """width""": 18}
									_lowerCAmelCase      			=					parent
									_lowerCAmelCase      			=					batch_size
									_lowerCAmelCase      			=					num_channels
									_lowerCAmelCase      			=					image_size
									_lowerCAmelCase      			=					min_resolution
									_lowerCAmelCase      			=					max_resolution
									_lowerCAmelCase      			=					do_resize
									_lowerCAmelCase      			=					size
									_lowerCAmelCase      			=					do_normalize
									_lowerCAmelCase      			=					image_mean
									_lowerCAmelCase      			=					image_std




				def 							snake_case     (							self	):



									"""simple docstring"""





									return {
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_normalize": self.do_normalize,
									    "do_resize": self.do_resize,
									    "size": self.size,
									}





@require_torch
@require_vision
class       __lowerCAmelCase				(  lowerCamelCase__ ,		unittest.TestCase ):
				__lowerCamelCase				=       EfficientNetImageProcessor if is_vision_available() else None




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					EfficientNetImageProcessorTester(self	)




				@property
				def 							snake_case     (							self	):



									"""simple docstring"""





									return self.image_processor_tester.prepare_image_processor_dict()




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									self.assertTrue(hasattr(_snake_case		,       """image_mean"""	)	)
									self.assertTrue(hasattr(_snake_case		,       """image_std"""	)	)
									self.assertTrue(hasattr(_snake_case		,       """do_normalize"""	)	)
									self.assertTrue(hasattr(_snake_case		,       """do_resize"""	)	)
									self.assertTrue(hasattr(_snake_case		,       """size"""	)	)




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class.from_dict(self.image_processor_dict	)
									self.assertEqual(image_processor.size		,       {"""height""": 18, """width""": 18}	)

									_lowerCAmelCase      			=					self.image_processing_class.from_dict(self.image_processor_dict		,       size=42	)
									self.assertEqual(image_processor.size		,       {"""height""": 42, """width""": 42}	)




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random PIL images
									_lowerCAmelCase      			=					prepare_image_inputs(self.image_processor_tester		,       equal_resolution=_snake_case	)
									for image in image_inputs:
														self.assertIsInstance(_snake_case		,       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.size["""height"""],
									        self.image_processor_tester.size["""width"""],
									    )		,       )

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




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random numpy tensors
									_lowerCAmelCase      			=					prepare_image_inputs(self.image_processor_tester		,       equal_resolution=_snake_case		,       numpify=_snake_case	)
									for image in image_inputs:
														self.assertIsInstance(_snake_case		,       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.size["""height"""],
									        self.image_processor_tester.size["""width"""],
									    )		,       )

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




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random PyTorch tensors
									_lowerCAmelCase      			=					prepare_image_inputs(self.image_processor_tester		,       equal_resolution=_snake_case		,       torchify=_snake_case	)
									for image in image_inputs:
														self.assertIsInstance(_snake_case		,       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.size["""height"""],
									        self.image_processor_tester.size["""width"""],
									    )		,       )

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








from typing import TYPE_CHECKING

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


A__			   = {
    """configuration_videomae""": ["""VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """VideoMAEConfig"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A__			   = [
	    """VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """VideoMAEForPreTraining""",
	    """VideoMAEModel""",
	    """VideoMAEPreTrainedModel""",
	    """VideoMAEForVideoClassification""",
	]

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A__			   = ["""VideoMAEFeatureExtractor"""]
	A__			   = ["""VideoMAEImageProcessor"""]

if TYPE_CHECKING:
	from .configuration_videomae import VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP, VideoMAEConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_videomae import (
		    VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    VideoMAEForPreTraining,
		    VideoMAEForVideoClassification,
		    VideoMAEModel,
		    VideoMAEPreTrainedModel,
		)

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_videomae import VideoMAEFeatureExtractor
		from .image_processing_videomae import VideoMAEImageProcessor

else:
	import sys

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



