

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


class     lowerCamelCase_   ( unittest.TestCase):







 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     ,     ):
   __UpperCAmelCase  :     int		=    size if size is not None else {'height': 224, 'width': 224}
   __UpperCAmelCase  :     Tuple		=    crop_size if crop_size is not None else {'height': 224, 'width': 224}
   __UpperCAmelCase  :     Any		=    codebook_size if codebook_size is not None else {'height': 112, 'width': 112}
   __UpperCAmelCase  :     List[str]		=    codebook_crop_size if codebook_crop_size is not None else {'height': 112, 'width': 112}

   __UpperCAmelCase  :     Optional[int]		=    parent
   __UpperCAmelCase  :     Dict		=    batch_size
   __UpperCAmelCase  :     int		=    num_channels
   __UpperCAmelCase  :     List[str]		=    do_resize
   __UpperCAmelCase  :     Optional[int]		=    do_rescale
   __UpperCAmelCase  :     Optional[Any]		=    rescale_factor
   __UpperCAmelCase  :     str		=    min_resolution
   __UpperCAmelCase  :     Union[str, Any]		=    max_resolution
   __UpperCAmelCase  :     List[Any]		=    size
   __UpperCAmelCase  :     int		=    resample if resample is not None else PILImageResampling.BICUBIC
   __UpperCAmelCase  :     Optional[Any]		=    do_normalize
   __UpperCAmelCase  :     int		=    image_mean
   __UpperCAmelCase  :     int		=    image_std
   __UpperCAmelCase  :     Optional[int]		=    do_center_crop
   __UpperCAmelCase  :     List[str]		=    crop_size

   __UpperCAmelCase  :     int		=    input_size_patches
   __UpperCAmelCase  :     Union[str, Any]		=    total_mask_patches
   __UpperCAmelCase  :     Optional[int]		=    mask_group_max_patches
   __UpperCAmelCase  :     Dict		=    mask_group_min_patches
   __UpperCAmelCase  :     Any		=    mask_group_min_aspect_ratio
   __UpperCAmelCase  :     List[str]		=    mask_group_max_aspect_ratio

   __UpperCAmelCase  :     Optional[int]		=    codebook_do_resize
   __UpperCAmelCase  :     Optional[int]		=    codebook_size
   __UpperCAmelCase  :     Dict		=    codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
   __UpperCAmelCase  :     int		=    codebook_do_center_crop
   __UpperCAmelCase  :     Optional[int]		=    codebook_crop_size
   __UpperCAmelCase  :     List[str]		=    codebook_do_map_pixels
   __UpperCAmelCase  :     List[str]		=    codebook_do_normalize
   __UpperCAmelCase  :     Optional[Any]		=    codebook_image_mean
   __UpperCAmelCase  :     Union[str, Any]		=    codebook_image_std







 def 						a					( self       ):
   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       ):
   return (self.size["height"], self.size["width"])







 def 						a					( self       ):
   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       ):
   return (self.codebook_size["height"], self.codebook_size["width"])



@require_torch
@require_vision
class     lowerCamelCase_   ( _lowerCAmelCase  ,							unittest.TestCase):
 _lowerCAmelCase       		=  FlavaImageProcessor if is_vision_available() else None
 _lowerCAmelCase       		=  None







 def 						a					( self       ):
   __UpperCAmelCase  :     Any		=    FlavaImageProcessingTester(self       )







 @property
 def 						a					( self       ):
   return self.image_processor_tester.prepare_image_processor_dict()







 def 						a					( self       ):
   __UpperCAmelCase  :     Union[str, Any]		=    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       ):
   __UpperCAmelCase  :     str		=    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}       )

   __UpperCAmelCase  :     Optional[Any]		=    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       ):
   pass







 def 						a					( self       ):
   # Initialize image_processing
   __UpperCAmelCase  :     Union[str, Any]		=    self.image_processing_class(**self.image_processor_dict       )
   # create random PIL images
   __UpperCAmelCase  :     Optional[int]		=    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
   __UpperCAmelCase  :     Union[str, Any]		=    image_processing(image_inputs[0]     ,     return_tensors='pt'       )

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

   __UpperCAmelCase  :     str		=    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
   __UpperCAmelCase  :     Union[str, Any]		=    image_processing(_UpperCAmelCase     ,     return_tensors='pt'       )
   __UpperCAmelCase  :     Optional[int]		=    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       ):
   # Initialize image_processing
   __UpperCAmelCase  :     Optional[Any]		=    self.image_processing_class(**self.image_processor_dict       )
   # create random tensors
   __UpperCAmelCase  :     int		=    prepare_image_inputs(self.image_processor_tester     ,     equal_resolution=_UpperCAmelCase     ,     **_UpperCAmelCase       )
   for image in image_inputs:
     self.assertIsInstance(_UpperCAmelCase     ,     _UpperCAmelCase       )

   # Test not batched input
   __UpperCAmelCase  :     Optional[int]		=    image_processing(image_inputs[0]     ,     return_tensors='pt'       )

   __UpperCAmelCase  :     Tuple		=    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)     ,     )

   __UpperCAmelCase  :     Tuple		=    image_processing(_UpperCAmelCase     ,     return_image_mask=_UpperCAmelCase     ,     return_tensors='pt'       )

   __UpperCAmelCase  :     Tuple		=    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,
       )     ,     )

   __UpperCAmelCase  :     Any		=    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
   __UpperCAmelCase  :     int		=    image_processing(_UpperCAmelCase     ,     return_tensors='pt'       ).pixel_values

   __UpperCAmelCase  :     Optional[Any]		=    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
   __UpperCAmelCase  :     List[str]		=    image_processing(_UpperCAmelCase     ,     return_image_mask=_UpperCAmelCase     ,     return_tensors='pt'       )

   __UpperCAmelCase  :     Dict		=    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,
       )     ,     )

   __UpperCAmelCase  :     Dict		=    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       ):
   self._test_call_framework(np.ndarray     ,     prepare_kwargs={'numpify': True}       )







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







 def 						a					( self       ):
   # Initialize image_processing
   random.seed(1_234       )
   __UpperCAmelCase  :     Dict		=    self.image_processing_class(**self.image_processor_dict       )
   __UpperCAmelCase  :     Optional[Any]		=    prepare_image_inputs(self.image_processor_tester     ,     equal_resolution=_UpperCAmelCase     ,     torchify=_UpperCAmelCase       )

   # Test not batched input
   __UpperCAmelCase  :     Any		=    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       ):
   # Initialize image_processing
   __UpperCAmelCase  :     List[str]		=    self.image_processing_class(**self.image_processor_dict       )
   # create random PIL images
   __UpperCAmelCase  :     Optional[int]		=    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
   __UpperCAmelCase  :     int		=    image_processing(image_inputs[0]     ,     return_codebook_pixels=_UpperCAmelCase     ,     return_tensors='pt'       )
   __UpperCAmelCase  :     Any		=    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
   __UpperCAmelCase  :     Union[str, Any]		=    image_processing(_UpperCAmelCase     ,     return_codebook_pixels=_UpperCAmelCase     ,     return_tensors='pt'       )
   __UpperCAmelCase  :     List[Any]		=    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 __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from typing import Any


class     lowerCamelCase_   :
 _lowerCAmelCase       		=  ('''_front''', '''_back''', '''_len''')


 @dataclass
 class     lowerCamelCase_   :
  _lowerCAmelCase       		=  None
  _lowerCAmelCase       		=  None
  _lowerCAmelCase       		=  None



 class     lowerCamelCase_   :
  _lowerCAmelCase       		=  ('''_cur''',)




  def __init__( self     ,     _UpperCAmelCase       ):
    __UpperCAmelCase  :     Tuple		=    cur




  def __iter__( self       ):
    return self




  def 						a					( self       ):
    if self._cur is None:
      # finished iterating
      raise StopIteration
    __UpperCAmelCase  :     str		=    self._cur.val
    __UpperCAmelCase  :     Dict		=    self._cur.next_node

    return val




 def __init__( self     ,     _UpperCAmelCase = None       ):
   __UpperCAmelCase  :     Any		=    None
   __UpperCAmelCase  :     Any		=    None
   __UpperCAmelCase  :     int		=    0

   if iterable is not None:
     # append every value to the deque
     for val in iterable:
       self.append(_UpperCAmelCase       )




 def 						a					( self     ,     _UpperCAmelCase       ):
   __UpperCAmelCase  :     Optional[Any]		=    self._Node(_UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase       )
   if self.is_empty():
     # front = back
     __UpperCAmelCase  :     Dict		=    node
     __UpperCAmelCase  :     List[str]		=    1
   else:
     # connect nodes
     __UpperCAmelCase  :     Any		=    node
     __UpperCAmelCase  :     Tuple		=    self._back
     __UpperCAmelCase  :     Optional[Any]		=    node  # assign new back to the new node

     self._len += 1

     # make sure there were no errors
     assert not self.is_empty(), "Error on appending value."




 def 						a					( self     ,     _UpperCAmelCase       ):
   __UpperCAmelCase  :     Optional[Any]		=    self._Node(_UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase       )
   if self.is_empty():
     # front = back
     __UpperCAmelCase  :     str		=    node
     __UpperCAmelCase  :     List[str]		=    1
   else:
     # connect nodes
     __UpperCAmelCase  :     List[str]		=    self._front
     __UpperCAmelCase  :     Any		=    node
     __UpperCAmelCase  :     Dict		=    node  # assign new front to the new node

     self._len += 1

     # make sure there were no errors
     assert not self.is_empty(), "Error on appending value."




 def 						a					( self     ,     _UpperCAmelCase       ):
   for val in iterable:
     self.append(_UpperCAmelCase       )




 def 						a					( self     ,     _UpperCAmelCase       ):
   for val in iterable:
     self.appendleft(_UpperCAmelCase       )




 def 						a					( self       ):
   assert not self.is_empty(), "Deque is empty."

   __UpperCAmelCase  :     List[Any]		=    self._back
   __UpperCAmelCase  :     Optional[int]		=    self._back.prev_node  # set new back
   # drop the last node - python will deallocate memory automatically
   __UpperCAmelCase  :     int		=    None

   self._len -= 1

   return topop.val




 def 						a					( self       ):
   assert not self.is_empty(), "Deque is empty."

   __UpperCAmelCase  :     List[Any]		=    self._front
   __UpperCAmelCase  :     Union[str, Any]		=    self._front.next_node  # set new front and drop the first node
   __UpperCAmelCase  :     Union[str, Any]		=    None

   self._len -= 1

   return topop.val




 def 						a					( self       ):
   return self._front is None




 def __len__( self       ):
   return self._len




 def __eq__( self     ,     _UpperCAmelCase       ):

   if not isinstance(_UpperCAmelCase     ,     _UpperCAmelCase       ):
     return NotImplemented

   __UpperCAmelCase  :     List[str]		=    self._front
   __UpperCAmelCase  :     str		=    other._front

   # if the length of the dequeues are not the same, they are not equal
   if len(self       ) != len(_UpperCAmelCase       ):
     return False

   while me is not None and oth is not None:
     # compare every value
     if me.val != oth.val:
       return False
     __UpperCAmelCase  :     Any		=    me.next_node
     __UpperCAmelCase  :     str		=    oth.next_node

   return True




 def __iter__( self       ):
   return Deque._Iterator(self._front       )




 def __repr__( self       ):
   __UpperCAmelCase  :     int		=    []
   __UpperCAmelCase  :     Dict		=    self._front
   while aux is not None:
     # append the values in a list to display
     values_list.append(aux.val       )
     __UpperCAmelCase  :     List[str]		=    aux.next_node

   return F"[{', '.join(repr(_UpperCAmelCase       ) for val in values_list       )}]"


if __name__ == "__main__":
      import doctest

      doctest.testmod()





