






'''simple docstring'''







from typing import TYPE_CHECKING

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


__lowerCAmelCase					   =       {"""configuration_hubert""": ["""HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """HubertConfig"""]}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase					   =       [
      """HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """HubertForCTC""",
      """HubertForSequenceClassification""",
      """HubertModel""",
      """HubertPreTrainedModel""",
  ]


try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase					   =       [
      """TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFHubertForCTC""",
      """TFHubertModel""",
      """TFHubertPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_hubert import HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, HubertConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_hubert import (
        HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        HubertForCTC,
        HubertForSequenceClassification,
        HubertModel,
        HubertPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_hubert import (
        TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFHubertForCTC,
        TFHubertModel,
        TFHubertPreTrainedModel,
    )


else:
  import sys

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












'''simple docstring'''







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:
  __lowerCAmelCase					   =       __lowerCAmelCase					   =       __lowerCAmelCase					   =       __lowerCAmelCase					   =       None




class      __SCREAMING_SNAKE_CASE					(unittest.TestCase					):


  """simple docstring"""


  def __init__( self      ,  UpperCamelCase__      ,  UpperCamelCase__=7      ,  UpperCamelCase__=3      ,  UpperCamelCase__=30      ,  UpperCamelCase__=400      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=1 / 255      ,  UpperCamelCase__=True      ,  UpperCamelCase__=FLAVA_IMAGE_MEAN      ,  UpperCamelCase__=FLAVA_IMAGE_STD      ,  UpperCamelCase__=14      ,  UpperCamelCase__=75      ,  UpperCamelCase__=None      ,  UpperCamelCase__=16      ,  UpperCamelCase__=0.3      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=FLAVA_CODEBOOK_MEAN      ,  UpperCamelCase__=FLAVA_CODEBOOK_STD      ,  ):






         """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       _a					( 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,
             "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       _a					( self  ):






         """simple docstring"""


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







  def       _a					( self  ):






         """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       _a					( self  ):






         """simple docstring"""


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





@require_torch
@require_vision
class      __SCREAMING_SNAKE_CASE					(__A       ,					unittest.TestCase					):


  """simple docstring"""


  _a     :   Union[str, Any]			 =    FlavaImageProcessor if is_vision_available() else None
  _a     :   Dict			 =    None







  def       _a					( self  ):






         """simple docstring"""


         a_	    = FlavaImageProcessingTester(self  )







  @property
  def       _a					( self  ):






         """simple docstring"""


         return self.image_processor_tester.prepare_image_processor_dict()







  def       _a					( self  ):






         """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       _a					( self  ):






         """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       _a					( self  ):






         """simple docstring"""


         pass







  def       _a					( self  ):






         """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       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """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       _a					( self  ):






         """simple docstring"""


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







  def       _a					( self  ):






         """simple docstring"""


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







  def       _a					( self  ):






         """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       _a					( self  ):






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




