






import random
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():
     import PIL

     from transformers import FlavaImageProcessor
     from transformers.image_utils import PILImageResampling
     from transformers.models.flava.image_processing_flava import (
         FLAVA_CODEBOOK_MEAN,
         FLAVA_CODEBOOK_STD,
         FLAVA_IMAGE_MEAN,
         FLAVA_IMAGE_STD,
     )
else:
     UpperCAmelCase__            =	UpperCAmelCase__            =	UpperCAmelCase__            =	UpperCAmelCase__            =	None






class 	lowercase_      (			unittest.TestCase     ):






      '''simple docstring'''




      def __init__(   self   :		Optional[int]				,      __UpperCAmelCase   :		Optional[int]				,      __UpperCAmelCase   :		Any=7				,      __UpperCAmelCase   :		Any=3				,      __UpperCAmelCase   :		int=30				,      __UpperCAmelCase   :		Dict=400				,      __UpperCAmelCase   :		Optional[Any]=True				,      __UpperCAmelCase   :		str=None				,      __UpperCAmelCase   :		str=True				,      __UpperCAmelCase   :		Dict=None				,      __UpperCAmelCase   :		str=None				,      __UpperCAmelCase   :		List[Any]=True				,      __UpperCAmelCase   :		Any=1 / 255				,      __UpperCAmelCase   :		str=True				,      __UpperCAmelCase   :		List[str]=FLAVA_IMAGE_MEAN				,      __UpperCAmelCase   :		int=FLAVA_IMAGE_STD				,      __UpperCAmelCase   :		str=14				,      __UpperCAmelCase   :		Union[str, Any]=75				,      __UpperCAmelCase   :		str=None				,      __UpperCAmelCase   :		Optional[Any]=16				,      __UpperCAmelCase   :		Any=0.3				,      __UpperCAmelCase   :		Tuple=None				,      __UpperCAmelCase   :		Any=True				,      __UpperCAmelCase   :		Dict=None				,      __UpperCAmelCase   :		Optional[Any]=None				,      __UpperCAmelCase   :		List[str]=True				,      __UpperCAmelCase   :		Tuple=None				,      __UpperCAmelCase   :		str=True				,      __UpperCAmelCase   :		Any=True				,      __UpperCAmelCase   :		Optional[Any]=FLAVA_CODEBOOK_MEAN				,      __UpperCAmelCase   :		Dict=FLAVA_CODEBOOK_STD				,      )					->str:




       """simple docstring"""


       a							=   size if size is not None else {'''height''': 224, '''width''': 224}
       a							=   crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
       a							=   codebook_size if codebook_size is not None else {'''height''': 112, '''width''': 112}
       a							=   codebook_crop_size if codebook_crop_size is not None else {'''height''': 112, '''width''': 112}

       a							=   parent
       a							=   batch_size
       a							=   num_channels
       a							=   do_resize
       a							=   do_rescale
       a							=   rescale_factor
       a							=   min_resolution
       a							=   max_resolution
       a							=   size
       a							=   resample if resample is not None else PILImageResampling.BICUBIC
       a							=   do_normalize
       a							=   image_mean
       a							=   image_std
       a							=   do_center_crop
       a							=   crop_size

       a							=   input_size_patches
       a							=   total_mask_patches
       a							=   mask_group_max_patches
       a							=   mask_group_min_patches
       a							=   mask_group_min_aspect_ratio
       a							=   mask_group_max_aspect_ratio

       a							=   codebook_do_resize
       a							=   codebook_size
       a							=   codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
       a							=   codebook_do_center_crop
       a							=   codebook_crop_size
       a							=   codebook_do_map_pixels
       a							=   codebook_do_normalize
       a							=   codebook_image_mean
       a							=   codebook_image_std







      def    __lowerCAmelCase      (   self   :		Optional[Any]						)					->Dict:




       """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,
           "resample": self.resample,
           "do_rescale": self.do_rescale,
           "rescale_factor": self.rescale_factor,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
           "input_size_patches": self.input_size_patches,
           "total_mask_patches": self.total_mask_patches,
           "mask_group_max_patches": self.mask_group_max_patches,
           "mask_group_min_patches": self.mask_group_min_patches,
           "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
           "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
           "codebook_do_resize": self.codebook_do_resize,
           "codebook_size": self.codebook_size,
           "codebook_resample": self.codebook_resample,
           "codebook_do_center_crop": self.codebook_do_center_crop,
           "codebook_crop_size": self.codebook_crop_size,
           "codebook_do_map_pixels": self.codebook_do_map_pixels,
           "codebook_do_normalize": self.codebook_do_normalize,
           "codebook_image_mean": self.codebook_image_mean,
           "codebook_image_std": self.codebook_image_std,
       }







      def    __lowerCAmelCase      (   self   :		List[Any]						)					->int:




       """simple docstring"""


       return (self.size["height"], self.size["width"])







      def    __lowerCAmelCase      (   self   :		Tuple						)					->Tuple:




       """simple docstring"""


       return (
           (self.input_size_patches, self.input_size_patches)
           if not isinstance(self.input_size_patches				,      __UpperCAmelCase						)
           else self.input_size_patches
       )







      def    __lowerCAmelCase      (   self   :		int						)					->Tuple:




       """simple docstring"""


       return (self.codebook_size["height"], self.codebook_size["width"])






@require_torch
@require_vision
class 	lowercase_      (			lowercase				,						unittest.TestCase     ):






      '''simple docstring'''




      __snake_case  						=						FlavaImageProcessor if is_vision_available() else None
      __snake_case  						=						None







      def    __lowerCAmelCase      (   self   :		Union[str, Any]						)					->Optional[int]:




       """simple docstring"""


       a							=   FlavaImageProcessingTester(self						)







      @property
      def    __lowerCAmelCase      (   self   :		Dict						)					->Any:




       """simple docstring"""


       return self.image_processor_tester.prepare_image_processor_dict()







      def    __lowerCAmelCase      (   self   :		List[Any]						)					->int:




       """simple docstring"""


       a							=   self.image_processing_class(**self.image_processor_dict						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''image_mean'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''image_std'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''do_normalize'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''do_resize'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''resample'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''crop_size'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''do_center_crop'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''do_rescale'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''rescale_factor'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''masking_generator'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_do_resize'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_size'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_resample'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_do_center_crop'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_crop_size'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_do_map_pixels'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_do_normalize'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_image_mean'''						)						)
       self.assertTrue(hasattr(__UpperCAmelCase				,      '''codebook_image_std'''						)						)







      def    __lowerCAmelCase      (   self   :		str						)					->Optional[int]:




       """simple docstring"""


       a							=   self.image_processing_class.from_dict(self.image_processor_dict						)
       self.assertEqual(image_processor.size				,      {'''height''': 224, '''width''': 224}						)
       self.assertEqual(image_processor.crop_size				,      {'''height''': 224, '''width''': 224}						)
       self.assertEqual(image_processor.codebook_size				,      {'''height''': 112, '''width''': 112}						)
       self.assertEqual(image_processor.codebook_crop_size				,      {'''height''': 112, '''width''': 112}						)

       a							=   self.image_processing_class.from_dict(
           self.image_processor_dict				,      size=42				,      crop_size=84				,      codebook_size=33				,      codebook_crop_size=66						)
       self.assertEqual(image_processor.size				,      {'''height''': 42, '''width''': 42}						)
       self.assertEqual(image_processor.crop_size				,      {'''height''': 84, '''width''': 84}						)
       self.assertEqual(image_processor.codebook_size				,      {'''height''': 33, '''width''': 33}						)
       self.assertEqual(image_processor.codebook_crop_size				,      {'''height''': 66, '''width''': 66}						)







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




       """simple docstring"""


       pass







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




       """simple docstring"""


       a							=   self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       a							=   prepare_image_inputs(self.image_processor_tester				,      equal_resolution=__UpperCAmelCase						)
       for image in image_inputs:
        self.assertIsInstance(__UpperCAmelCase				,      PIL.Image.Image						)

       # Test not batched input
       a							=   image_processing(image_inputs[0]				,      return_tensors='''pt'''						)

       # Test no bool masked pos
       self.assertFalse('''bool_masked_pos''' in encoded_images						)

       a						,  a							=   self.image_processor_tester.get_expected_image_size()

       self.assertEqual(
           encoded_images.pixel_values.shape				,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,      )

       # Test batched
       a							=   image_processing(__UpperCAmelCase				,      return_tensors='''pt'''						)
       a						,  a							=   self.image_processor_tester.get_expected_image_size()

       # Test no bool masked pos
       self.assertFalse('''bool_masked_pos''' in encoded_images						)

       self.assertEqual(
           encoded_images.pixel_values.shape				,      (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )				,      )







      def    __lowerCAmelCase      (   self   :		Dict				,      __UpperCAmelCase   :		Dict				,      __UpperCAmelCase   :		int						)					->int:




       """simple docstring"""


       a							=   self.image_processing_class(**self.image_processor_dict						)
       # create random tensors
       a							=   prepare_image_inputs(self.image_processor_tester				,      equal_resolution=__UpperCAmelCase				,      **__UpperCAmelCase						)
       for image in image_inputs:
        self.assertIsInstance(__UpperCAmelCase				,      __UpperCAmelCase						)

       # Test not batched input
       a							=   image_processing(image_inputs[0]				,      return_tensors='''pt'''						)

       a						,  a							=   self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape				,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,      )

       a							=   image_processing(__UpperCAmelCase				,      return_image_mask=__UpperCAmelCase				,      return_tensors='''pt'''						)

       a						,  a							=   self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape				,      (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )				,      )

       a						,  a							=   self.image_processor_tester.get_expected_mask_size()
       self.assertEqual(
           encoded_images.bool_masked_pos.shape				,      (
               self.image_processor_tester.batch_size,
               expected_height,
               expected_width,
           )				,      )

       # Test batched
       a							=   image_processing(__UpperCAmelCase				,      return_tensors='''pt'''						).pixel_values

       a						,  a							=   self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.shape				,      (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )				,      )

       # Test masking
       a							=   image_processing(__UpperCAmelCase				,      return_image_mask=__UpperCAmelCase				,      return_tensors='''pt'''						)

       a						,  a							=   self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape				,      (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )				,      )

       a						,  a							=   self.image_processor_tester.get_expected_mask_size()
       self.assertEqual(
           encoded_images.bool_masked_pos.shape				,      (
               self.image_processor_tester.batch_size,
               expected_height,
               expected_width,
           )				,      )







      def    __lowerCAmelCase      (   self   :		Optional[int]						)					->Optional[int]:




       """simple docstring"""


       self._test_call_framework(np.ndarray				,      prepare_kwargs={'''numpify''': True}						)







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




       """simple docstring"""


       self._test_call_framework(torch.Tensor				,      prepare_kwargs={'''torchify''': True}						)







      def    __lowerCAmelCase      (   self   :		List[Any]						)					->int:




       """simple docstring"""


       random.seed(1_234						)
       a							=   self.image_processing_class(**self.image_processor_dict						)
       a							=   prepare_image_inputs(self.image_processor_tester				,      equal_resolution=__UpperCAmelCase				,      torchify=__UpperCAmelCase						)

       # Test not batched input
       a							=   image_processing(image_inputs[0]				,      return_image_mask=__UpperCAmelCase				,      return_tensors='''pt'''						)
       self.assertEqual(encoded_images.bool_masked_pos.sum().item()				,      75						)







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




       """simple docstring"""


       a							=   self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       a							=   prepare_image_inputs(self.image_processor_tester				,      equal_resolution=__UpperCAmelCase						)
       for image in image_inputs:
        self.assertIsInstance(__UpperCAmelCase				,      PIL.Image.Image						)

       # Test not batched input
       a							=   image_processing(image_inputs[0]				,      return_codebook_pixels=__UpperCAmelCase				,      return_tensors='''pt'''						)
       a						,  a							=   self.image_processor_tester.get_expected_codebook_image_size()
       self.assertEqual(
           encoded_images.codebook_pixel_values.shape				,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,      )

       # Test batched
       a							=   image_processing(__UpperCAmelCase				,      return_codebook_pixels=__UpperCAmelCase				,      return_tensors='''pt'''						)
       a						,  a							=   self.image_processor_tester.get_expected_codebook_image_size()
       self.assertEqual(
           encoded_images.codebook_pixel_values.shape				,      (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )				,      )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__            =	{"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__            =	[
         "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "VisualBertForMultipleChoice",
         "VisualBertForPreTraining",
         "VisualBertForQuestionAnswering",
         "VisualBertForRegionToPhraseAlignment",
         "VisualBertForVisualReasoning",
         "VisualBertLayer",
         "VisualBertModel",
         "VisualBertPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_visual_bert import (
              VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              VisualBertForMultipleChoice,
              VisualBertForPreTraining,
              VisualBertForQuestionAnswering,
              VisualBertForRegionToPhraseAlignment,
              VisualBertForVisualReasoning,
              VisualBertLayer,
              VisualBertModel,
              VisualBertPreTrainedModel,
          )


else:
     import sys

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


