

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

       from transformers import LevitImageProcessor







class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=7,    lowercase_=3,    lowercase_=18,    lowercase_=30,    lowercase_=400,    lowercase_=True,    lowercase_=None,    lowercase_=True,    lowercase_=None,    lowercase_=True,    lowercase_=[0.5, 0.5, 0.5],    lowercase_=[0.5, 0.5, 0.5],    )							->    Dict:






     """simple docstring"""






     a__  =size if size is not None else {'''shortest_edge''': 18}
     a__  =crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
     a__  =parent
     a__  =batch_size
     a__  =num_channels
     a__  =image_size
     a__  =min_resolution
     a__  =max_resolution
     a__  =do_resize
     a__  =size
     a__  =do_center_crop
     a__  =crop_size
     a__  =do_normalize
     a__  =image_mean
     a__  =image_std



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






     """simple docstring"""






     return {
         "image_mean": self.image_mean,
         "image_std": self.image_std,
         "do_normalize": self.do_normalize,
         "do_resize": self.do_resize,
         "do_center_crop": self.do_center_crop,
         "size": self.size,
         "crop_size": self.crop_size,
     }







@require_torch
@require_vision
class 						__magic_name__			(							lowerCamelCase__		,       unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   LevitImageProcessor if is_vision_available() else None



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =LevitImageProcessingTester(self       )



   @property
   def  _UpperCAmelCase (				self       )							->    List[Any]:






     """simple docstring"""






     return self.image_processor_tester.prepare_image_processor_dict()



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






     """simple docstring"""






     a__  =self.image_processing_class(**self.image_processor_dict       )
     self.assertTrue(hasattr(lowercase_,    '''image_mean'''       )       )
     self.assertTrue(hasattr(lowercase_,    '''image_std'''       )       )
     self.assertTrue(hasattr(lowercase_,    '''do_normalize'''       )       )
     self.assertTrue(hasattr(lowercase_,    '''do_resize'''       )       )
     self.assertTrue(hasattr(lowercase_,    '''do_center_crop'''       )       )
     self.assertTrue(hasattr(lowercase_,    '''size'''       )       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =self.image_processing_class.from_dict(self.image_processor_dict       )
     self.assertEqual(image_processor.size,    {'''shortest_edge''': 18}       )
     self.assertEqual(image_processor.crop_size,    {'''height''': 18, '''width''': 18}       )

     a__  =self.image_processing_class.from_dict(self.image_processor_dict,    size=42,    crop_size=84       )
     self.assertEqual(image_processor.size,    {'''shortest_edge''': 42}       )
     self.assertEqual(image_processor.crop_size,    {'''height''': 84, '''width''': 84}       )



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






     """simple docstring"""






     pass



   def  _UpperCAmelCase (				self       )							->    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=lowercase_       )
     for image in image_inputs:
       self.assertIsInstance(lowercase_,    Image.Image       )

     # Test not batched input
     a__  =image_processing(image_inputs[0],    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )

     # Test batched
     a__  =image_processing(lowercase_,    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )



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






     """simple docstring"""






     a__  =self.image_processing_class(**self.image_processor_dict       )
     # create random numpy tensors
     a__  =prepare_image_inputs(self.image_processor_tester,    equal_resolution=lowercase_,    numpify=lowercase_       )
     for image in image_inputs:
       self.assertIsInstance(lowercase_,    np.ndarray       )

     # Test not batched input
     a__  =image_processing(image_inputs[0],    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )

     # Test batched
     a__  =image_processing(lowercase_,    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )



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






     """simple docstring"""






     a__  =self.image_processing_class(**self.image_processor_dict       )
     # create random PyTorch tensors
     a__  =prepare_image_inputs(self.image_processor_tester,    equal_resolution=lowercase_,    torchify=lowercase_       )
     for image in image_inputs:
       self.assertIsInstance(lowercase_,    torch.Tensor       )

     # Test not batched input
     a__  =image_processing(image_inputs[0],    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )

     # Test batched
     a__  =image_processing(lowercase_,    return_tensors='''pt'''       ).pixel_values
     self.assertEqual(
         encoded_images.shape,    (
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         ),    )



def 			UpperCAmelCase__				(			_A      : dict							):





  '''simple docstring'''







  a__  =set()
  # To detect a back edge, keep track of vertices currently in the recursion stack
  a__  =set()
  return any(
      node not in visited and depth_first_search(_A	,      _A	,      _A	,      _A							)
      for node in graph							)




def 			UpperCAmelCase__				(			_A      : dict	,      _A      : int	,      _A      : set	,      _A      : set							):





  '''simple docstring'''







  visited.add(_A							)
  rec_stk.add(_A							)

  for node in graph[vertex]:
    if node not in visited:
      if depth_first_search(_A	,      _A	,      _A	,      _A							):
        return True
    elif node in rec_stk:
      return True

    # The node needs to be removed from recursion stack before function ends
  rec_stk.remove(_A							)
  return False


if __name__ == "__main__":
       from doctest import testmod

       testmod()
