






"""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
from typing import Dict, List, Optional, Union

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 BridgeTowerImageProcessor





class   UpperCamelCase_ (       unittest.TestCase  ):



  def __init__(      self ,		snake_case__ ,		snake_case__ = True ,		snake_case__ = None ,		snake_case__ = 32 ,		snake_case__ = True ,		snake_case__ = 1 / 2_55 ,		snake_case__ = True ,		snake_case__ = True ,		snake_case__ = [0.48_145_466, 0.4_578_275, 0.40_821_073] ,		snake_case__ = [0.26_862_954, 0.26_130_258, 0.27_577_711] ,		snake_case__ = True ,		snake_case__=7 ,		snake_case__=30 ,		snake_case__=4_00 ,		snake_case__=3 ,		)			->			Union[str, Any]:



         """simple docstring"""





         UpperCAmelCase	    =			parent
         UpperCAmelCase	    =			do_resize
         UpperCAmelCase	    =			size if size is not None else {"""shortest_edge""": 2_88}
         UpperCAmelCase	    =			size_divisor
         UpperCAmelCase	    =			do_rescale
         UpperCAmelCase	    =			rescale_factor
         UpperCAmelCase	    =			do_normalize
         UpperCAmelCase	    =			do_center_crop
         UpperCAmelCase	    =			image_mean
         UpperCAmelCase	    =			image_std
         UpperCAmelCase	    =			do_pad
         UpperCAmelCase	    =			batch_size
         UpperCAmelCase	    =			num_channels
         UpperCAmelCase	    =			min_resolution
         UpperCAmelCase	    =			max_resolution



  def 		UpperCamelCase_				(      self				)			->			int:



         """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,
             "size_divisor": self.size_divisor,
         }



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__=False				)			->			Optional[int]:



         """simple docstring"""





         if not batched:
                UpperCAmelCase	    =			self.size["""shortest_edge"""]
                UpperCAmelCase	    =			image_inputs[0]
                if isinstance(snake_case__ ,		Image.Image				):
                       UpperCAmelCase    ,       UpperCAmelCase	    =			image.size
                else:
                       UpperCAmelCase    ,       UpperCAmelCase	    =			image.shape[1], image.shape[2]
                UpperCAmelCase	    =			size / min(snake_case__ ,		snake_case__				)
                if h < w:
                       UpperCAmelCase    ,       UpperCAmelCase	    =			size, scale * w
                else:
                       UpperCAmelCase    ,       UpperCAmelCase	    =			scale * h, size

                UpperCAmelCase	    =			int((13_33 / 8_00) * size				)
                if max(snake_case__ ,		snake_case__				) > max_size:
                       UpperCAmelCase	    =			max_size / max(snake_case__ ,		snake_case__				)
                       UpperCAmelCase	    =			newh * scale
                       UpperCAmelCase	    =			neww * scale

                UpperCAmelCase    ,       UpperCAmelCase	    =			int(newh + 0.5				), int(neww + 0.5				)
                UpperCAmelCase    ,       UpperCAmelCase	    =			(
                    newh // self.size_divisor * self.size_divisor,
                    neww // self.size_divisor * self.size_divisor,
                )

         else:
                UpperCAmelCase	    =			[]
                for image in image_inputs:
                       UpperCAmelCase    ,       UpperCAmelCase	    =			self.get_expected_values([image]				)
                       expected_values.append((expected_height, expected_width)				)
                UpperCAmelCase	    =			max(snake_case__ ,		key=lambda snake_case__				: item[0]				)[0]
                UpperCAmelCase	    =			max(snake_case__ ,		key=lambda snake_case__				: item[1]				)[1]

         return expected_height, expected_width





@require_torch
@require_vision
class   UpperCamelCase_ (       a_   ,					unittest.TestCase  ):
  _A       :					int				=	BridgeTowerImageProcessor if is_vision_available() else None



  def 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         UpperCAmelCase	    =			BridgeTowerImageProcessingTester(self				)



  @property
  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         return self.image_processor_tester.prepare_image_processor_dict()



  def 		UpperCamelCase_				(      self				)			->			List[str]:



         """simple docstring"""





         UpperCAmelCase	    =			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"""				)				)
         self.assertTrue(hasattr(snake_case__ ,		"""size_divisor"""				)				)



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



         """simple docstring"""





         pass



  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			self.image_processing_class(**self.image_processor_dict				)
         # create random PIL images
         UpperCAmelCase	    =			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
         UpperCAmelCase	    =			image_processing(image_inputs[0] ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,		)

         # Test batched
         UpperCAmelCase	    =			image_processing(snake_case__ ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__ ,		batched=snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             ) ,		)



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         UpperCAmelCase	    =			self.image_processing_class(**self.image_processor_dict				)
         # create random numpy tensors
         UpperCAmelCase	    =			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
         UpperCAmelCase	    =			image_processing(image_inputs[0] ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,		)

         # Test batched
         UpperCAmelCase	    =			image_processing(snake_case__ ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__ ,		batched=snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             ) ,		)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase	    =			self.image_processing_class(**self.image_processor_dict				)
         # create random PyTorch tensors
         UpperCAmelCase	    =			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
         UpperCAmelCase	    =			image_processing(image_inputs[0] ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width) ,		)

         # Test batched
         UpperCAmelCase	    =			image_processing(snake_case__ ,		return_tensors="""pt"""				).pixel_values

         UpperCAmelCase    ,       UpperCAmelCase	    =			self.image_processor_tester.get_expected_values(snake_case__ ,		batched=snake_case__				)
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             ) ,		)
