





"""simple docstring"""
__UpperCamelCase    :	Tuple						=     {0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}

__UpperCamelCase    :	Any						=     {0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}

def 		_SCREAMING_SNAKE_CASE (_UpperCAmelCase				:						dict     ,    _UpperCAmelCase				:						int     ,    _UpperCAmelCase				:						list ):
 lowerCAmelCase													=   True
 lowerCAmelCase													=   []

 for neighbour in graph[vert]:
  if not visited[neighbour]:
   connected_verts += dfs(_UpperCAmelCase     ,    _UpperCAmelCase     ,    _UpperCAmelCase )

 return [vert, *connected_verts]

def 		_SCREAMING_SNAKE_CASE (_UpperCAmelCase				:						dict ):
 lowerCAmelCase													=   len(_UpperCAmelCase )
 lowerCAmelCase													=   graph_size * [False]
 lowerCAmelCase													=   []

 for i in range(_UpperCAmelCase ):
  if not visited[i]:
   lowerCAmelCase													=   dfs(_UpperCAmelCase     ,    _UpperCAmelCase     ,    _UpperCAmelCase )
   components_list.append(_UpperCAmelCase )

 return components_list


if __name__ == "__main__":
       import doctest

       doctest.testmod()












"""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:
       __UpperCamelCase    :	Union[str, Any]						=     None







class 			a       (      unittest.TestCase     ):



 def __init__(    self							,					_snake_case							,					_snake_case=7							,					_snake_case=3							,					_snake_case=30							,					_snake_case=4_00							,					_snake_case=True							,					_snake_case=None							,					_snake_case=True							,					_snake_case=None							,					_snake_case=None							,					_snake_case=True							,					_snake_case=1 / 2_55							,					_snake_case=True							,					_snake_case=FLAVA_IMAGE_MEAN							,					_snake_case=FLAVA_IMAGE_STD							,					_snake_case=14							,					_snake_case=75							,					_snake_case=None							,					_snake_case=16							,					_snake_case=0.3							,					_snake_case=None							,					_snake_case=True							,					_snake_case=None							,					_snake_case=None							,					_snake_case=True							,					_snake_case=None							,					_snake_case=True							,					_snake_case=True							,					_snake_case=FLAVA_CODEBOOK_MEAN							,					_snake_case=FLAVA_CODEBOOK_STD							,					):







  """simple docstring"""






  lowerCAmelCase													=   size if size is not None else {'height': 2_24, 'width': 2_24}
  lowerCAmelCase													=   crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
  lowerCAmelCase													=   codebook_size if codebook_size is not None else {'height': 1_12, 'width': 1_12}
  lowerCAmelCase													=   codebook_crop_size if codebook_crop_size is not None else {'height': 1_12, 'width': 1_12}

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

  lowerCAmelCase													=   input_size_patches
  lowerCAmelCase													=   total_mask_patches
  lowerCAmelCase													=   mask_group_max_patches
  lowerCAmelCase													=   mask_group_min_patches
  lowerCAmelCase													=   mask_group_min_aspect_ratio
  lowerCAmelCase													=   mask_group_max_aspect_ratio

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



 def       UpperCamelCase__     (    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       UpperCamelCase__     (    self    ):







  """simple docstring"""






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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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







@require_torch
@require_vision
class 			a       (      a__      ,   unittest.TestCase     ):
 snake_case__								=					FlavaImageProcessor if is_vision_available() else None
 snake_case__								=					None



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   FlavaImageProcessingTester(self    )



 @property
 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  return self.image_processor_tester.prepare_image_processor_dict()



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   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							,					'resample'    )    )
  self.assertTrue(hasattr(_snake_case							,					'crop_size'    )    )
  self.assertTrue(hasattr(_snake_case							,					'do_center_crop'    )    )
  self.assertTrue(hasattr(_snake_case							,					'do_rescale'    )    )
  self.assertTrue(hasattr(_snake_case							,					'rescale_factor'    )    )
  self.assertTrue(hasattr(_snake_case							,					'masking_generator'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_do_resize'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_size'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_resample'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_do_center_crop'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_crop_size'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_do_map_pixels'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_do_normalize'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_image_mean'    )    )
  self.assertTrue(hasattr(_snake_case							,					'codebook_image_std'    )    )



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  lowerCAmelCase													=   self.image_processing_class.from_dict(self.image_processor_dict    )
  self.assertEqual(image_processor.size							,					{'height': 2_24, 'width': 2_24}    )
  self.assertEqual(image_processor.crop_size							,					{'height': 2_24, 'width': 2_24}    )
  self.assertEqual(image_processor.codebook_size							,					{'height': 1_12, 'width': 1_12}    )
  self.assertEqual(image_processor.codebook_crop_size							,					{'height': 1_12, 'width': 1_12}    )

  lowerCAmelCase													=   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       UpperCamelCase__     (    self    ):







  """simple docstring"""






  pass



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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

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

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

  lowerCAmelCase							,lowerCAmelCase													=   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
  lowerCAmelCase													=   image_processing(_snake_case							,					return_tensors='pt'    )
  lowerCAmelCase							,lowerCAmelCase													=   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       UpperCamelCase__     (    self							,					_snake_case							,					_snake_case    ):







  """simple docstring"""






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

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

  lowerCAmelCase							,lowerCAmelCase													=   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)							,					)

  lowerCAmelCase													=   image_processing(_snake_case							,					return_image_mask=_snake_case							,					return_tensors='pt'    )

  lowerCAmelCase							,lowerCAmelCase													=   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,
      )							,					)

  lowerCAmelCase							,lowerCAmelCase													=   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
  lowerCAmelCase													=   image_processing(_snake_case							,					return_tensors='pt'    ).pixel_values

  lowerCAmelCase							,lowerCAmelCase													=   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
  lowerCAmelCase													=   image_processing(_snake_case							,					return_image_mask=_snake_case							,					return_tensors='pt'    )

  lowerCAmelCase							,lowerCAmelCase													=   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,
      )							,					)

  lowerCAmelCase							,lowerCAmelCase													=   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       UpperCamelCase__     (    self    ):







  """simple docstring"""






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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






  random.seed(12_34    )
  lowerCAmelCase													=   self.image_processing_class(**self.image_processor_dict    )
  lowerCAmelCase													=   prepare_image_inputs(self.image_processor_tester							,					equal_resolution=_snake_case							,					torchify=_snake_case    )

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



 def       UpperCamelCase__     (    self    ):







  """simple docstring"""






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

  # Test not batched input
  lowerCAmelCase													=   image_processing(image_inputs[0]							,					return_codebook_pixels=_snake_case							,					return_tensors='pt'    )
  lowerCAmelCase							,lowerCAmelCase													=   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
  lowerCAmelCase													=   image_processing(_snake_case							,					return_codebook_pixels=_snake_case							,					return_tensors='pt'    )
  lowerCAmelCase							,lowerCAmelCase													=   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,
      )							,					)





