




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










'''simple docstring'''
import unittest

import numpy as np

from transformers.testing_utils import is_flaky, 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 DonutImageProcessor
class   __UpperCAmelCase				(     unittest.TestCase				):



					'''simple docstring'''





					def __init__(	self     :						int      ,       _lowercase     :						Any      ,       _lowercase     :						Tuple=7      ,       _lowercase     :						Tuple=3      ,       _lowercase     :						str=18      ,       _lowercase     :						Union[str, Any]=30      ,       _lowercase     :						Dict=400      ,       _lowercase     :						int=True      ,       _lowercase     :						List[Any]=None      ,       _lowercase     :						int=True      ,       _lowercase     :						Optional[int]=False      ,       _lowercase     :						str=True      ,       _lowercase     :						Union[str, Any]=True      ,       _lowercase     :						Any=[0.5, 0.5, 0.5]      ,       _lowercase     :						str=[0.5, 0.5, 0.5]      ,       )    ->							Optional[Any]:
								A_									= parent
								A_									= batch_size
								A_									= num_channels
								A_									= image_size
								A_									= min_resolution
								A_									= max_resolution
								A_									= do_resize
								A_									= size if size is not None else {'height': 18, 'width': 20}
								A_									= do_thumbnail
								A_									= do_align_axis
								A_									= do_pad
								A_									= do_normalize
								A_									= image_mean
								A_									= image_std



					def     __snake_case						(	self     :						int)    ->							int:
								return {
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "do_thumbnail": self.do_thumbnail,
								    "do_align_long_axis": self.do_align_axis,
								    "do_pad": self.do_pad,
								    "do_normalize": self.do_normalize,
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								}





@require_torch
@require_vision
class   __UpperCAmelCase				(     lowerCAmelCase			,unittest.TestCase				):



					'''simple docstring'''





					_UpperCamelCase							=		DonutImageProcessor if is_vision_available() else None



					def     __snake_case						(	self     :						Optional[int])    ->							Union[str, Any]:
								A_									= DonutImageProcessingTester(self)



					@property
					def     __snake_case						(	self     :						int)    ->							int:
								return self.image_processor_tester.prepare_image_processor_dict()



					def     __snake_case						(	self     :						Any)    ->							Tuple:
								A_									= self.image_processing_class(**self.image_processor_dict)
								self.assertTrue(hasattr(_lowercase      ,       'do_resize'))
								self.assertTrue(hasattr(_lowercase      ,       'size'))
								self.assertTrue(hasattr(_lowercase      ,       'do_thumbnail'))
								self.assertTrue(hasattr(_lowercase      ,       'do_align_long_axis'))
								self.assertTrue(hasattr(_lowercase      ,       'do_pad'))
								self.assertTrue(hasattr(_lowercase      ,       'do_normalize'))
								self.assertTrue(hasattr(_lowercase      ,       'image_mean'))
								self.assertTrue(hasattr(_lowercase      ,       'image_std'))



					def     __snake_case						(	self     :						int)    ->							Optional[int]:
								A_									= self.image_processing_class.from_dict(self.image_processor_dict)
								self.assertEqual(image_processor.size      ,       {'height': 18, 'width': 20})

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

								# Previous config had dimensions in (width, height) order
								A_									= self.image_processing_class.from_dict(self.image_processor_dict      ,       size=(42, 84))
								self.assertEqual(image_processor.size      ,       {'height': 84, 'width': 42})



					def     __snake_case						(	self     :						Optional[Any])    ->							Optional[Any]:
								pass



					@is_flaky()
					def     __snake_case						(	self     :						List[str])    ->							int:
								# Initialize image_processing
								A_									= self.image_processing_class(**self.image_processor_dict)
								# create random PIL images
								A_									= prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=_lowercase)
								for image in image_inputs:
											self.assertIsInstance(_lowercase      ,       Image.Image)

								# Test not batched input
								A_									= 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
								A_									= image_processing(_lowercase      ,       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'],
								    )      ,       )



					@is_flaky()
					def     __snake_case						(	self     :						List[Any])    ->							List[Any]:
								# Initialize image_processing
								A_									= self.image_processing_class(**self.image_processor_dict)
								# create random numpy tensors
								A_									= prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=_lowercase      ,       numpify=_lowercase)
								for image in image_inputs:
											self.assertIsInstance(_lowercase      ,       np.ndarray)

								# Test not batched input
								A_									= 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
								A_									= image_processing(_lowercase      ,       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'],
								    )      ,       )



					@is_flaky()
					def     __snake_case						(	self     :						Dict)    ->							int:
								# Initialize image_processing
								A_									= self.image_processing_class(**self.image_processor_dict)
								# create random PyTorch tensors
								A_									= prepare_image_inputs(self.image_processor_tester      ,       equal_resolution=_lowercase      ,       torchify=_lowercase)
								for image in image_inputs:
											self.assertIsInstance(_lowercase      ,       torch.Tensor)

								# Test not batched input
								A_									= 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
								A_									= image_processing(_lowercase      ,       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'],
								    )      ,       )




