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


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import ViTImageProcessor
class   SCREAMING_SNAKE_CASE			(						unittest.TestCase):







		"""simple docstring"""






		def __init__(   self		,						__A		,						__A=13		,						__A=3		,						__A=224		,						__A=30		,						__A=400		,						__A=True		,						__A=None		,						__A=True		,						__A=[0.5, 0.5, 0.5]		,						__A=[0.5, 0.5, 0.5]		,						) ->     Any:
								_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 		UpperCamelCase__       (   self				) ->     Optional[Any]:
								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   SCREAMING_SNAKE_CASE			(						__lowercase    ,			unittest.TestCase):







		"""simple docstring"""
		lowercase   :      Dict       =							ViTImageProcessor if is_vision_available() else None






		def 		UpperCamelCase__       (   self				) ->     Any:
								_lowerCAmelCase										=EfficientFormerImageProcessorTester(self				)






		@property
		def 		UpperCamelCase__       (   self				) ->     int:
								return self.image_proc_tester.prepare_image_processor_dict()






		def 		UpperCamelCase__       (   self				) ->     List[str]:
								_lowerCAmelCase										=self.image_processing_class(**self.image_processor_dict				)
								self.assertTrue(hasattr(__A		,						'image_mean'				)				)
								self.assertTrue(hasattr(__A		,						'image_std'				)				)
								self.assertTrue(hasattr(__A		,						'do_normalize'				)				)
								self.assertTrue(hasattr(__A		,						'do_resize'				)				)
								self.assertTrue(hasattr(__A		,						'size'				)				)






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






		def 		UpperCamelCase__       (   self				) ->     List[str]:
								# Initialize image_processor
								_lowerCAmelCase										=self.image_processing_class(**self.image_processor_dict				)
								# create random PIL images
								_lowerCAmelCase										=prepare_image_inputs(self.image_proc_tester		,						equal_resolution=__A				)
								for image in image_inputs:
														self.assertIsInstance(__A		,						Image.Image				)

								# Test not batched input
								_lowerCAmelCase										=image_processor(image_inputs[0]		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        1,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)

								# Test batched
								_lowerCAmelCase										=image_processor(__A		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        self.image_proc_tester.batch_size,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)






		def 		UpperCamelCase__       (   self				) ->     int:
								# Initialize image_processor
								_lowerCAmelCase										=self.image_processing_class(**self.image_processor_dict				)
								# create random numpy tensors
								_lowerCAmelCase										=prepare_image_inputs(self.image_proc_tester		,						equal_resolution=__A		,						numpify=__A				)
								for image in image_inputs:
														self.assertIsInstance(__A		,						np.ndarray				)

								# Test not batched input
								_lowerCAmelCase										=image_processor(image_inputs[0]		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        1,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)

								# Test batched
								_lowerCAmelCase										=image_processor(__A		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        self.image_proc_tester.batch_size,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)






		def 		UpperCamelCase__       (   self				) ->     List[Any]:
								# Initialize image_processor
								_lowerCAmelCase										=self.image_processing_class(**self.image_processor_dict				)
								# create random PyTorch tensors
								_lowerCAmelCase										=prepare_image_inputs(self.image_proc_tester		,						equal_resolution=__A		,						torchify=__A				)
								for image in image_inputs:
														self.assertIsInstance(__A		,						torch.Tensor				)

								# Test not batched input
								_lowerCAmelCase										=image_processor(image_inputs[0]		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        1,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)

								# Test batched
								_lowerCAmelCase										=image_processor(__A		,						return_tensors='pt'				).pixel_values
								self.assertEqual(
								    encoded_images.shape		,						(
								        self.image_proc_tester.batch_size,
								        self.image_proc_tester.num_channels,
								        self.image_proc_tester.size['height'],
								        self.image_proc_tester.size['width'],
								    )		,						)






'''simple docstring'''

from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)





