






import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
       MODEL_MAPPING,
       LevitForImageClassification,
       LevitForImageClassificationWithTeacher,
       LevitModel,
   )
   from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import LevitImageProcessor


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    self.config_class(**self.inputs_dict      )
       self.parent.assertTrue(hasattr(UpperCAmelCase_					, "hidden_sizes"      )      )
       self.parent.assertTrue(hasattr(UpperCAmelCase_					, "num_attention_heads"      )      )





class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     def __init__(				self       :	Any					, UpperCAmelCase_       :	List[Any]					, UpperCAmelCase_       :	Optional[int]=13					, UpperCAmelCase_       :	Optional[int]=64					, UpperCAmelCase_       :	Union[str, Any]=3					, UpperCAmelCase_       :	Tuple=3					, UpperCAmelCase_       :	Tuple=2					, UpperCAmelCase_       :	Optional[Any]=1					, UpperCAmelCase_       :	int=16					, UpperCAmelCase_       :	List[str]=[128, 256, 384]					, UpperCAmelCase_       :	List[str]=[4, 6, 8]					, UpperCAmelCase_       :	Tuple=[2, 3, 4]					, UpperCAmelCase_       :	Dict=[16, 16, 16]					, UpperCAmelCase_       :	Union[str, Any]=0					, UpperCAmelCase_       :	Union[str, Any]=[2, 2, 2]					, UpperCAmelCase_       :	List[str]=[2, 2, 2]					, UpperCAmelCase_       :	Any=0.02					, UpperCAmelCase_       :	Any=True					, UpperCAmelCase_       :	Optional[int]=True					, UpperCAmelCase_       :	Optional[Any]=2					, ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    parent
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    batch_size
       SCREAMING_SNAKE_CASE       :      int							=    image_size
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    num_channels
       SCREAMING_SNAKE_CASE       :      Tuple							=    kernel_size
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    stride
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    padding
       SCREAMING_SNAKE_CASE       :      int							=    hidden_sizes
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    num_attention_heads
       SCREAMING_SNAKE_CASE       :      List[Any]							=    depths
       SCREAMING_SNAKE_CASE       :      str							=    key_dim
       SCREAMING_SNAKE_CASE       :      str							=    drop_path_rate
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    patch_size
       SCREAMING_SNAKE_CASE       :      List[Any]							=    attention_ratio
       SCREAMING_SNAKE_CASE       :      Dict							=    mlp_ratio
       SCREAMING_SNAKE_CASE       :      str							=    initializer_range
       SCREAMING_SNAKE_CASE       :      str							=    [
           ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
           ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
       ]
       SCREAMING_SNAKE_CASE       :      str							=    is_training
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    use_labels
       SCREAMING_SNAKE_CASE       :      List[Any]							=    num_labels
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    initializer_range


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    None
       if self.use_labels:
         SCREAMING_SNAKE_CASE       :      str							=    ids_tensor([self.batch_size]					, self.num_labels      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    self.get_config()
       return config, pixel_values, labels


     def 				_A       (				self       :	Optional[int]      ):
       return LevitConfig(
           image_size=self.image_size					, num_channels=self.num_channels					, kernel_size=self.kernel_size					, stride=self.stride					, padding=self.padding					, patch_size=self.patch_size					, hidden_sizes=self.hidden_sizes					, num_attention_heads=self.num_attention_heads					, depths=self.depths					, key_dim=self.key_dim					, drop_path_rate=self.drop_path_rate					, mlp_ratio=self.mlp_ratio					, attention_ratio=self.attention_ratio					, initializer_range=self.initializer_range					, down_ops=self.down_ops					, )


     def 				_A       (				self       :	List[Any]					, UpperCAmelCase_       :	Optional[int]					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    LevitModel(config=UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      List[Any]							=    (self.image_size, self.image_size)
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Tuple							=    image_size[0], image_size[1]
       for _ in range(4      ):
         SCREAMING_SNAKE_CASE       :      int							=    floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1      )
         SCREAMING_SNAKE_CASE       :      List[str]							=    floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1      )
       self.parent.assertEqual(
           result.last_hidden_state.shape					, (self.batch_size, ceil(height / 4      ) * ceil(width / 4      ), self.hidden_sizes[-1])					, )


     def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Any      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    self.num_labels
       SCREAMING_SNAKE_CASE       :      Tuple							=    LevitForImageClassification(UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      Tuple							=    model(UpperCAmelCase_					, labels=UpperCAmelCase_      )
       self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels)      )






     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Optional[Any]							=    config_and_inputs
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    {"pixel_values": pixel_values}
       return config, inputs_dict





@require_torch
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Optional[int]			=	(
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     UpperCamelCase_							:		int			=	(
         {
             '''feature-extraction''': LevitModel,
             '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     UpperCamelCase_							:		List[Any]			=	False
     UpperCamelCase_							:		Tuple			=	False
     UpperCamelCase_							:		Dict			=	False
     UpperCamelCase_							:		Optional[int]			=	False
     UpperCamelCase_							:		Tuple			=	False


     def 				_A       (				self       :	int      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    LevitModelTester(self      )
       SCREAMING_SNAKE_CASE       :      int							=    ConfigTester(self					, config_class=UpperCAmelCase_					, has_text_modality=UpperCAmelCase_					, hidden_size=37      )


     def 				_A       (				self       :	Optional[Any]      ):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()


     def 				_A       (				self       :	Tuple      ):
       return


     @unittest.skip(reason="Levit does not use inputs_embeds"      )
     def 				_A       (				self       :	Tuple      ):
       pass


     @unittest.skip(reason="Levit does not support input and output embeddings"      )
     def 				_A       (				self       :	int      ):
       pass


     @unittest.skip(reason="Levit does not output attentions"      )
     def 				_A       (				self       :	int      ):
       pass


     def 				_A       (				self       :	str      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      int							=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      Dict							=    model_class(UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      Tuple							=    inspect.signature(model.forward      )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         SCREAMING_SNAKE_CASE       :      Any							=    [*signature.parameters.keys()]

         SCREAMING_SNAKE_CASE       :      str							=    ["pixel_values"]
         self.assertListEqual(arg_names[:1]					, UpperCAmelCase_      )


     def 				_A       (				self       :	int      ):
       def check_hidden_states_output(UpperCAmelCase_       :	Tuple					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Tuple      ):
         SCREAMING_SNAKE_CASE       :      Dict							=    model_class(UpperCAmelCase_      )
         model.to(UpperCAmelCase_      )
         model.eval()

         with torch.no_grad():
           SCREAMING_SNAKE_CASE       :      Dict							=    model(**self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )

         SCREAMING_SNAKE_CASE       :      Optional[int]							=    outputs.hidden_states

         SCREAMING_SNAKE_CASE       :      List[str]							=    len(self.model_tester.depths      ) + 1
         self.assertEqual(len(UpperCAmelCase_      )					, UpperCAmelCase_      )

         SCREAMING_SNAKE_CASE       :      List[str]							=    (self.model_tester.image_size, self.model_tester.image_size)
         SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      List[str]							=    image_size[0], image_size[1]
         for _ in range(4      ):
           SCREAMING_SNAKE_CASE       :      Dict							=    floor(
               (
                   (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                   / self.model_tester.stride
               )
               + 1      )
           SCREAMING_SNAKE_CASE       :      Any							=    floor(
               (
                   (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                   / self.model_tester.stride
               )
               + 1      )
         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]      )					, [
                 height * width,
                 self.model_tester.hidden_sizes[0],
             ]					, )

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      str							=    True
         check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    True

         check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )


     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."      )
     def 				_A       (				self       :	Optional[int]      ):
       pass


     def 				_A       (				self       :	Tuple					, UpperCAmelCase_       :	Optional[int]					, UpperCAmelCase_       :	List[Any]					, UpperCAmelCase_       :	List[str]=False      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    super()._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_					, return_labels=UpperCAmelCase_      )

       if return_labels:
         if model_class.__name__ == "LevitForImageClassificationWithTeacher":
           del inputs_dict["labels"]

       return inputs_dict


     def 				_A       (				self       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase_      )


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_      )


     def 				_A       (				self       :	int      ):
       if not self.model_tester.is_training:
         return

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      List[str]							=    self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE       :      str							=    True

       for model_class in self.all_model_classes:
         # LevitForImageClassificationWithTeacher supports inference-only
         if (
             model_class in get_values(UpperCAmelCase_      )
             or model_class.__name__ == "LevitForImageClassificationWithTeacher"
         ):
           continue
         SCREAMING_SNAKE_CASE       :      Dict							=    model_class(UpperCAmelCase_      )
         model.to(UpperCAmelCase_      )
         model.train()
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_					, return_labels=UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    model(**UpperCAmelCase_      ).loss
         loss.backward()


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
         return

       SCREAMING_SNAKE_CASE       :      Tuple							=    False
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    True

       for model_class in self.all_model_classes:
         if model_class in get_values(UpperCAmelCase_      ) or not model_class.supports_gradient_checkpointing:
           continue
         # LevitForImageClassificationWithTeacher supports inference-only
         if model_class.__name__ == "LevitForImageClassificationWithTeacher":
           continue
         SCREAMING_SNAKE_CASE       :      int							=    model_class(UpperCAmelCase_      )
         model.gradient_checkpointing_enable()
         model.to(UpperCAmelCase_      )
         model.train()
         SCREAMING_SNAKE_CASE       :      Tuple							=    self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_					, return_labels=UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      List[Any]							=    model(**UpperCAmelCase_      ).loss
         loss.backward()


     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      str							=    self.model_tester.prepare_config_and_inputs_for_common()

       SCREAMING_SNAKE_CASE       :      List[str]							=    [
           {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float},
           {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long},
           {"title": "regression", "num_labels": 1, "dtype": torch.float},
       ]

       for model_class in self.all_model_classes:
         if (
             model_class
             not in [
                 *get_values(UpperCAmelCase_      ),
             ]
             or model_class.__name__ == "LevitForImageClassificationWithTeacher"
         ):
           continue

         for problem_type in problem_types:
           with self.subTest(msg=f'''Testing {model_class} with {problem_type['title']}'''      ):
             SCREAMING_SNAKE_CASE       :      Tuple							=    problem_type["title"]
             SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    problem_type["num_labels"]

             SCREAMING_SNAKE_CASE       :      List[Any]							=    model_class(UpperCAmelCase_      )
             model.to(UpperCAmelCase_      )
             model.train()

             SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_					, return_labels=UpperCAmelCase_      )

             if problem_type["num_labels"] > 1:
               SCREAMING_SNAKE_CASE       :      List[Any]							=    inputs["labels"].unsqueeze(1      ).repeat(1					, problem_type["num_labels"]      )

             SCREAMING_SNAKE_CASE       :      Optional[int]							=    inputs["labels"].to(problem_type["dtype"]      )

             # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
             # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
             # they have the same size." which is a symptom something in wrong for the regression problem.
             # See https://github.com/huggingface/transformers/issues/11780
             with warnings.catch_warnings(record=UpperCAmelCase_      ) as warning_list:
               SCREAMING_SNAKE_CASE       :      int							=    model(**UpperCAmelCase_      ).loss
             for w in warning_list:
               if "Using a target size that is different to the input size" in str(w.message      ):
                 raise ValueError(
                     f'''Something is going wrong in the regression problem: intercepted {w.message}'''      )

             loss.backward()






     @slow
     def 				_A       (				self       :	Optional[int]      ):
       for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         SCREAMING_SNAKE_CASE       :      int							=    LevitModel.from_pretrained(UpperCAmelCase_      )
         self.assertIsNotNone(UpperCAmelCase_      )





def   lowerCamelCase__			(     ):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Dict							=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
  return image


@require_torch
@require_vision
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     @cached_property
     def 				_A       (				self       :	Union[str, Any]      ):
       return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )






     @slow
     def 				_A       (				self       :	str      ):
       SCREAMING_SNAKE_CASE       :      int							=    LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(
           UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.default_image_processor
       SCREAMING_SNAKE_CASE       :      Tuple							=    prepare_img()
       SCREAMING_SNAKE_CASE       :      Dict							=    image_processor(images=UpperCAmelCase_					, return_tensors="pt"      ).to(UpperCAmelCase_      )

       # forward pass
       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(**UpperCAmelCase_      )

       # verify the logits
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    torch.Size((1, 1000)      )
       self.assertEqual(outputs.logits.shape					, UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      List[Any]							=    torch.tensor([1.0_448, -0.3_745, -1.8_317]      ).to(UpperCAmelCase_      )

       self.assertTrue(torch.allclose(outputs.logits[0, :3]					, UpperCAmelCase_					, atol=1E-4      )      )














import unittest

import numpy as np

from transformers.testing_utils import is_flaky, 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 DonutImageProcessor


class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def __init__(				self       :	int					, UpperCAmelCase_       :	List[Any]					, UpperCAmelCase_       :	Tuple=7					, UpperCAmelCase_       :	Dict=3					, UpperCAmelCase_       :	Any=18					, UpperCAmelCase_       :	Optional[int]=30					, UpperCAmelCase_       :	Any=400					, UpperCAmelCase_       :	Optional[int]=True					, UpperCAmelCase_       :	Union[str, Any]=None					, UpperCAmelCase_       :	int=True					, UpperCAmelCase_       :	Optional[int]=False					, UpperCAmelCase_       :	List[Any]=True					, UpperCAmelCase_       :	Optional[Any]=True					, UpperCAmelCase_       :	Any=[0.5, 0.5, 0.5]					, UpperCAmelCase_       :	Dict=[0.5, 0.5, 0.5]					, ):
       SCREAMING_SNAKE_CASE       :      Any							=    parent
       SCREAMING_SNAKE_CASE       :      int							=    batch_size
       SCREAMING_SNAKE_CASE       :      Dict							=    num_channels
       SCREAMING_SNAKE_CASE       :      str							=    image_size
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    min_resolution
       SCREAMING_SNAKE_CASE       :      Any							=    max_resolution
       SCREAMING_SNAKE_CASE       :      int							=    do_resize
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    size if size is not None else {"height": 18, "width": 20}
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    do_thumbnail
       SCREAMING_SNAKE_CASE       :      Tuple							=    do_align_axis
       SCREAMING_SNAKE_CASE       :      List[str]							=    do_pad
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    do_normalize
       SCREAMING_SNAKE_CASE       :      Any							=    image_mean
       SCREAMING_SNAKE_CASE       :      Any							=    image_std






     def 				_A       (				self       :	str      ):
       return {
           "do_resize": self.do_resize,
           "size": self.size,
           "do_thumbnail": self.do_thumbnail,
           "do_align_long_axis": self.do_align_axis,
           "do_pad": self.do_pad,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
       }





@require_torch
@require_vision
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		str			=	DonutImageProcessor if is_vision_available() else None


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    DonutImageProcessingTester(self      )


     @property
     def 				_A       (				self       :	Tuple      ):
       return self.image_processor_tester.prepare_image_processor_dict()


     def 				_A       (				self       :	List[Any]      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.image_processing_class(**self.image_processor_dict      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "do_resize"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "size"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "do_thumbnail"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "do_align_long_axis"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "do_pad"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "do_normalize"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "image_mean"      )      )
       self.assertTrue(hasattr(UpperCAmelCase_					, "image_std"      )      )


     def 				_A       (				self       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      Any							=    self.image_processing_class.from_dict(self.image_processor_dict      )
       self.assertEqual(image_processor.size					, {"height": 18, "width": 20}      )

       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.image_processing_class.from_dict(self.image_processor_dict					, size=42      )
       self.assertEqual(image_processor.size					, {"height": 42, "width": 42}      )

       # Previous config had dimensions in (width, height) order
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.image_processing_class.from_dict(self.image_processor_dict					, size=(42, 84)      )
       self.assertEqual(image_processor.size					, {"height": 84, "width": 42}      )


     def 				_A       (				self       :	Dict      ):
       pass


     @is_flaky()
     def 				_A       (				self       :	Optional[Any]      ):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.image_processing_class(**self.image_processor_dict      )
       # create random PIL images
       SCREAMING_SNAKE_CASE       :      Tuple							=    prepare_image_inputs(self.image_processor_tester					, equal_resolution=UpperCAmelCase_      )
       for image in image_inputs:
         self.assertIsInstance(UpperCAmelCase_					, Image.Image      )

       # Test not batched input
       SCREAMING_SNAKE_CASE       :      List[str]							=    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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )

       # Test batched
       SCREAMING_SNAKE_CASE       :      Dict							=    image_processing(UpperCAmelCase_					, 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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )


     @is_flaky()
     def 				_A       (				self       :	List[str]      ):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE       :      Dict							=    self.image_processing_class(**self.image_processor_dict      )
       # create random numpy tensors
       SCREAMING_SNAKE_CASE       :      List[Any]							=    prepare_image_inputs(self.image_processor_tester					, equal_resolution=UpperCAmelCase_					, numpify=UpperCAmelCase_      )
       for image in image_inputs:
         self.assertIsInstance(UpperCAmelCase_					, np.ndarray      )

       # Test not batched input
       SCREAMING_SNAKE_CASE       :      Any							=    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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )

       # Test batched
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    image_processing(UpperCAmelCase_					, 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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )






     @is_flaky()
     def 				_A       (				self       :	Dict      ):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE       :      List[str]							=    self.image_processing_class(**self.image_processor_dict      )
       # create random PyTorch tensors
       SCREAMING_SNAKE_CASE       :      Tuple							=    prepare_image_inputs(self.image_processor_tester					, equal_resolution=UpperCAmelCase_					, torchify=UpperCAmelCase_      )
       for image in image_inputs:
         self.assertIsInstance(UpperCAmelCase_					, torch.Tensor      )

       # Test not batched input
       SCREAMING_SNAKE_CASE       :      int							=    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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )

       # Test batched
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    image_processing(UpperCAmelCase_					, 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.size["height"],
               self.image_processor_tester.size["width"],
           )					, )






