
"""simple docstring"""


import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
      import torch

      from transformers import (
          MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
          MODEL_FOR_QUESTION_ANSWERING_MAPPING,
          MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
          MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
          LayoutLMvaConfig,
          LayoutLMvaForQuestionAnswering,
          LayoutLMvaForSequenceClassification,
          LayoutLMvaForTokenClassification,
          LayoutLMvaModel,
      )
      from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
      from PIL import Image

      from transformers import LayoutLMvaImageProcessor



class 	__a	:






       def __init__(	self			:				Dict							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				int=2							,   UpperCAmelCase_			:				int=3							,   UpperCAmelCase_			:				List[Any]=4							,   UpperCAmelCase_			:				Optional[int]=2							,   UpperCAmelCase_			:				List[str]=7							,   UpperCAmelCase_			:				int=True							,   UpperCAmelCase_			:				str=True							,   UpperCAmelCase_			:				Any=True							,   UpperCAmelCase_			:				Dict=True							,   UpperCAmelCase_			:				Any=99							,   UpperCAmelCase_			:				List[Any]=36							,   UpperCAmelCase_			:				List[Any]=3							,   UpperCAmelCase_			:				str=4							,   UpperCAmelCase_			:				str=37							,   UpperCAmelCase_			:				Tuple="gelu"							,   UpperCAmelCase_			:				Dict=0.1							,   UpperCAmelCase_			:				Union[str, Any]=0.1							,   UpperCAmelCase_			:				Dict=512							,   UpperCAmelCase_			:				str=16							,   UpperCAmelCase_			:				int=2							,   UpperCAmelCase_			:				Optional[int]=0.02							,   UpperCAmelCase_			:				Union[str, Any]=6							,   UpperCAmelCase_			:				Any=6							,   UpperCAmelCase_			:				List[Any]=3							,   UpperCAmelCase_			:				Any=4							,   UpperCAmelCase_			:				Any=None							,   UpperCAmelCase_			:				Optional[Any]=1_000							,   )->	Union[str, Any]:







              """simple docstring"""
              UpperCamelCase       			=		parent
              UpperCamelCase       			=		batch_size
              UpperCamelCase       			=		num_channels
              UpperCamelCase       			=		image_size
              UpperCamelCase       			=		patch_size
              UpperCamelCase       			=		text_seq_length
              UpperCamelCase       			=		is_training
              UpperCamelCase       			=		use_input_mask
              UpperCamelCase       			=		use_token_type_ids
              UpperCamelCase       			=		use_labels
              UpperCamelCase       			=		vocab_size
              UpperCamelCase       			=		hidden_size
              UpperCamelCase       			=		num_hidden_layers
              UpperCamelCase       			=		num_attention_heads
              UpperCamelCase       			=		intermediate_size
              UpperCamelCase       			=		hidden_act
              UpperCamelCase       			=		hidden_dropout_prob
              UpperCamelCase       			=		attention_probs_dropout_prob
              UpperCamelCase       			=		max_position_embeddings
              UpperCamelCase       			=		type_vocab_size
              UpperCamelCase       			=		type_sequence_label_size
              UpperCamelCase       			=		initializer_range
              UpperCamelCase       			=		coordinate_size
              UpperCamelCase       			=		shape_size
              UpperCamelCase       			=		num_labels
              UpperCamelCase       			=		num_choices
              UpperCamelCase       			=		scope
              UpperCamelCase       			=		range_bbox

              # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
              UpperCamelCase       			=		text_seq_length
              UpperCamelCase       			=		(image_size // patch_size) ** 2 + 1
              UpperCamelCase       			=		self.text_seq_length + self.image_seq_length






       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[Any]      )->	List[Any]:







              """simple docstring"""
              UpperCamelCase       			=		ids_tensor([self.batch_size, self.text_seq_length]							,   self.vocab_size      )

              UpperCamelCase       			=		ids_tensor([self.batch_size, self.text_seq_length, 4]							,   self.range_bbox      )
              # Ensure that bbox is legal
              for i in range(bbox.shape[0]      ):
                     for j in range(bbox.shape[1]      ):
                            if bbox[i, j, 3] < bbox[i, j, 1]:
                                   UpperCamelCase       			=		bbox[i, j, 3]
                                   UpperCamelCase       			=		bbox[i, j, 1]
                                   UpperCamelCase       			=		t
                            if bbox[i, j, 2] < bbox[i, j, 0]:
                                   UpperCamelCase       			=		bbox[i, j, 2]
                                   UpperCamelCase       			=		bbox[i, j, 0]
                                   UpperCamelCase       			=		t

              UpperCamelCase       			=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

              UpperCamelCase       			=		None
              if self.use_input_mask:
                     UpperCamelCase       			=		random_attention_mask([self.batch_size, self.text_seq_length]      )

              UpperCamelCase       			=		None
              if self.use_token_type_ids:
                     UpperCamelCase       			=		ids_tensor([self.batch_size, self.text_seq_length]							,   self.type_vocab_size      )

              UpperCamelCase       			=		None
              UpperCamelCase       			=		None
              if self.use_labels:
                     UpperCamelCase       			=		ids_tensor([self.batch_size]							,   self.type_sequence_label_size      )
                     UpperCamelCase       			=		ids_tensor([self.batch_size, self.text_seq_length]							,   self.num_labels      )

              UpperCamelCase       			=		LayoutLMvaConfig(
                  vocab_size=self.vocab_size							,   hidden_size=self.hidden_size							,   num_hidden_layers=self.num_hidden_layers							,   num_attention_heads=self.num_attention_heads							,   intermediate_size=self.intermediate_size							,   hidden_act=self.hidden_act							,   hidden_dropout_prob=self.hidden_dropout_prob							,   attention_probs_dropout_prob=self.attention_probs_dropout_prob							,   max_position_embeddings=self.max_position_embeddings							,   type_vocab_size=self.type_vocab_size							,   initializer_range=self.initializer_range							,   coordinate_size=self.coordinate_size							,   shape_size=self.shape_size							,   input_size=self.image_size							,   patch_size=self.patch_size							,   )

              return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[int]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				Any							,   UpperCAmelCase_			:				str      )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		LayoutLMvaModel(config=UpperCAmelCase_      )
              model.to(UpperCAmelCase_      )
              model.eval()

              # text + image
              UpperCamelCase       			=		model(UpperCAmelCase_							,   pixel_values=UpperCAmelCase_      )
              UpperCamelCase       			=		model(
                  UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_							,   attention_mask=UpperCAmelCase_							,   token_type_ids=UpperCAmelCase_      )
              UpperCamelCase       			=		model(UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_							,   token_type_ids=UpperCAmelCase_      )
              UpperCamelCase       			=		model(UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_      )

              self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, self.seq_length, self.hidden_size)      )

              # text only
              UpperCamelCase       			=		model(UpperCAmelCase_      )
              self.parent.assertEqual(
                  result.last_hidden_state.shape							,   (self.batch_size, self.text_seq_length, self.hidden_size)      )

              # image only
              UpperCamelCase       			=		model(pixel_values=UpperCAmelCase_      )
              self.parent.assertEqual(
                  result.last_hidden_state.shape							,   (self.batch_size, self.image_seq_length, self.hidden_size)      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple							,   UpperCAmelCase_			:				Dict							,   UpperCAmelCase_			:				Any							,   UpperCAmelCase_			:				Optional[Any]							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				Union[str, Any]							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				Union[str, Any]      )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		self.num_labels
              UpperCamelCase       			=		LayoutLMvaForSequenceClassification(UpperCAmelCase_      )
              model.to(UpperCAmelCase_      )
              model.eval()
              UpperCamelCase       			=		model(
                  UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_							,   attention_mask=UpperCAmelCase_							,   token_type_ids=UpperCAmelCase_							,   labels=UpperCAmelCase_							,   )
              self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				int							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				str							,   UpperCAmelCase_			:				Any							,   UpperCAmelCase_			:				Dict							,   UpperCAmelCase_			:				str							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				Any      )->	Dict:







              """simple docstring"""
              UpperCamelCase       			=		self.num_labels
              UpperCamelCase       			=		LayoutLMvaForTokenClassification(config=UpperCAmelCase_      )
              model.to(UpperCAmelCase_      )
              model.eval()
              UpperCamelCase       			=		model(
                  UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_							,   attention_mask=UpperCAmelCase_							,   token_type_ids=UpperCAmelCase_							,   labels=UpperCAmelCase_							,   )
              self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.text_seq_length, self.num_labels)      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				List[str]							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				Optional[Any]							,   UpperCAmelCase_			:				Any							,   UpperCAmelCase_			:				Union[str, Any]							,   UpperCAmelCase_			:				int							,   UpperCAmelCase_			:				Optional[int]      )->	str:







              """simple docstring"""
              UpperCamelCase       			=		LayoutLMvaForQuestionAnswering(config=UpperCAmelCase_      )
              model.to(UpperCAmelCase_      )
              model.eval()
              UpperCamelCase       			=		model(
                  UpperCAmelCase_							,   bbox=UpperCAmelCase_							,   pixel_values=UpperCAmelCase_							,   attention_mask=UpperCAmelCase_							,   token_type_ids=UpperCAmelCase_							,   start_positions=UpperCAmelCase_							,   end_positions=UpperCAmelCase_							,   )
              self.parent.assertEqual(result.start_logits.shape							,   (self.batch_size, self.seq_length)      )
              self.parent.assertEqual(result.end_logits.shape							,   (self.batch_size, self.seq_length)      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				int      )->	Optional[Any]:







              """simple docstring"""
              UpperCamelCase       			=		self.prepare_config_and_inputs()
              (
                  (
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							(
                  UpperCamelCase
              )			,							
              )       			=		config_and_inputs
              UpperCamelCase       			=		{
                  "input_ids": input_ids,
                  "bbox": bbox,
                  "pixel_values": pixel_values,
                  "token_type_ids": token_type_ids,
                  "attention_mask": input_mask,
              }
              return config, inputs_dict





@require_torch
class 	__a	(   _lowerCAmelCase     ,  _lowerCAmelCase     ,  unittest.TestCase						):
       UpperCamelCase_		:       Optional[Any]				=      False
       UpperCamelCase_		:       Any				=      False
       UpperCamelCase_		:       List[Any]				=      False

       UpperCamelCase_		:       Dict				=      (
           (
               LayoutLMvaModel,
               LayoutLMvaForSequenceClassification,
               LayoutLMvaForTokenClassification,
               LayoutLMvaForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase_		:       Optional[int]				=      (
           {'''document-question-answering''': LayoutLMvaForQuestionAnswering, '''feature-extraction''': LayoutLMvaModel}
           if is_torch_available()
           else {}
       )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				List[Any]							,   UpperCAmelCase_			:				Tuple							,   UpperCAmelCase_			:				Union[str, Any]							,   UpperCAmelCase_			:				List[str]      )->	Dict:







              """simple docstring"""
              # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
              # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
              # the sequence dimension of the text embedding only.
              # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
              return True






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







              """simple docstring"""
              UpperCamelCase       			=		LayoutLMvaModelTester(self      )
              UpperCamelCase       			=		ConfigTester(self							,   config_class=UpperCAmelCase_							,   hidden_size=37      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]							,   UpperCAmelCase_			:				List[Any]							,   UpperCAmelCase_			:				List[Any]							,   UpperCAmelCase_			:				int=False      )->	Any:







              """simple docstring"""
              UpperCamelCase       			=		copy.deepcopy(UpperCAmelCase_      )
              if model_class in get_values(UpperCAmelCase_      ):
                     UpperCamelCase       			=		{
                         k: v.unsqueeze(1      ).expand(-1							,   self.model_tester.num_choices							,   -1      ).contiguous()
                         if isinstance(UpperCAmelCase_							,   torch.Tensor      ) and v.ndim > 1
                         else v
                         for k, v in inputs_dict.items()
                     }
              if return_labels:
                     if model_class in get_values(UpperCAmelCase_      ):
                            UpperCamelCase       			=		torch.ones(self.model_tester.batch_size							,   dtype=torch.long							,   device=UpperCAmelCase_      )
                     elif model_class in get_values(UpperCAmelCase_      ):
                            UpperCamelCase       			=		torch.zeros(
                                self.model_tester.batch_size							,   dtype=torch.long							,   device=UpperCAmelCase_      )
                            UpperCamelCase       			=		torch.zeros(
                                self.model_tester.batch_size							,   dtype=torch.long							,   device=UpperCAmelCase_      )
                     elif model_class in [
                         *get_values(UpperCAmelCase_      ),
                     ]:
                            UpperCamelCase       			=		torch.zeros(
                                self.model_tester.batch_size							,   dtype=torch.long							,   device=UpperCAmelCase_      )
                     elif model_class in [
                         *get_values(UpperCAmelCase_      ),
                     ]:
                            UpperCamelCase       			=		torch.zeros(
                                (self.model_tester.batch_size, self.model_tester.text_seq_length)							,   dtype=torch.long							,   device=UpperCAmelCase_							,   )

              return inputs_dict






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







              """simple docstring"""
              self.config_tester.run_common_tests()






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







              """simple docstring"""
              UpperCamelCase       			=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*UpperCAmelCase_      )






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







              """simple docstring"""
              UpperCamelCase       			=		self.model_tester.prepare_config_and_inputs()
              for type in ["absolute", "relative_key", "relative_key_query"]:
                     UpperCamelCase       			=		type
                     self.model_tester.create_and_check_model(*UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[Any]      )->	int:







              """simple docstring"""
              UpperCamelCase       			=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str      )->	Dict:







              """simple docstring"""
              UpperCamelCase       			=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_      )






       @slow
       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[int]      )->	int:







              """simple docstring"""
              for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     UpperCamelCase       			=		LayoutLMvaModel.from_pretrained(UpperCAmelCase_      )
                     self.assertIsNotNone(UpperCAmelCase_      )





def 						lowerCamelCase__      (				)->				Dict:







       """simple docstring"""
       UpperCamelCase       			=		Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
       return image



@require_torch
class 	__a	(   unittest.TestCase						):






       @cached_property
       def 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]      )->	Union[str, Any]:







              """simple docstring"""
              return LayoutLMvaImageProcessor(apply_ocr=UpperCAmelCase_      ) if is_vision_available() else None






       @slow
       def 						_SCREAMING_SNAKE_CASE							(	self			:				List[str]      )->	Optional[int]:







              """simple docstring"""
              UpperCamelCase       			=		LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"      ).to(UpperCAmelCase_      )

              UpperCamelCase       			=		self.default_image_processor
              UpperCamelCase       			=		prepare_img()
              UpperCamelCase       			=		image_processor(images=UpperCAmelCase_							,   return_tensors="pt"      ).pixel_values.to(UpperCAmelCase_      )

              UpperCamelCase       			=		torch.tensor([[1, 2]]      )
              UpperCamelCase       			=		torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]      ).unsqueeze(0      )

              # forward pass
              UpperCamelCase       			=		model(
                  input_ids=input_ids.to(UpperCAmelCase_      )							,   bbox=bbox.to(UpperCAmelCase_      )							,   pixel_values=pixel_values.to(UpperCAmelCase_      )							,   )

              # verify the logits
              UpperCamelCase       			=		torch.Size((1, 199, 768)      )
              self.assertEqual(outputs.last_hidden_state.shape							,   UpperCAmelCase_      )

              UpperCamelCase       			=		torch.tensor(
                  [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]      ).to(UpperCAmelCase_      )

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







"""simple docstring"""


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 PoolFormerImageProcessor



class 	__a	(   unittest.TestCase						):






       def __init__(	self			:				Optional[Any]							,   UpperCAmelCase_			:				Any							,   UpperCAmelCase_			:				Optional[Any]=7							,   UpperCAmelCase_			:				List[Any]=3							,   UpperCAmelCase_			:				Optional[int]=30							,   UpperCAmelCase_			:				Any=400							,   UpperCAmelCase_			:				Any=True							,   UpperCAmelCase_			:				Dict=None							,   UpperCAmelCase_			:				Dict=0.9							,   UpperCAmelCase_			:				Tuple=None							,   UpperCAmelCase_			:				Tuple=True							,   UpperCAmelCase_			:				Optional[int]=[0.5, 0.5, 0.5]							,   UpperCAmelCase_			:				Union[str, Any]=[0.5, 0.5, 0.5]							,   )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		size if size is not None else {"shortest_edge": 30}
              UpperCamelCase       			=		crop_size if crop_size is not None else {"height": 30, "width": 30}
              UpperCamelCase       			=		parent
              UpperCamelCase       			=		batch_size
              UpperCamelCase       			=		num_channels
              UpperCamelCase       			=		min_resolution
              UpperCamelCase       			=		max_resolution
              UpperCamelCase       			=		do_resize_and_center_crop
              UpperCamelCase       			=		size
              UpperCamelCase       			=		crop_pct
              UpperCamelCase       			=		crop_size
              UpperCamelCase       			=		do_normalize
              UpperCamelCase       			=		image_mean
              UpperCamelCase       			=		image_std






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]      )->	str:







              """simple docstring"""
              return {
                  "size": self.size,
                  "do_resize_and_center_crop": self.do_resize_and_center_crop,
                  "crop_pct": self.crop_pct,
                  "crop_size": self.crop_size,
                  "do_normalize": self.do_normalize,
                  "image_mean": self.image_mean,
                  "image_std": self.image_std,
              }





@require_torch
@require_vision
class 	__a	(   _lowerCAmelCase     ,  unittest.TestCase						):
       UpperCamelCase_		:       List[Any]				=      PoolFormerImageProcessor if is_vision_available() else None






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]      )->	str:







              """simple docstring"""
              UpperCamelCase       			=		PoolFormerImageProcessingTester(self      )






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







              """simple docstring"""
              return self.image_processor_tester.prepare_image_processor_dict()






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Dict      )->	Optional[int]:







              """simple docstring"""
              UpperCamelCase       			=		self.image_processing_class(**self.image_processor_dict      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "do_resize_and_center_crop"      )      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "size"      )      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "crop_pct"      )      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "do_normalize"      )      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "image_mean"      )      )
              self.assertTrue(hasattr(UpperCAmelCase_							,   "image_std"      )      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				int      )->	List[Any]:







              """simple docstring"""
              UpperCamelCase       			=		self.image_processing_class.from_dict(self.image_processor_dict      )
              self.assertEqual(image_processor.size							,   {"shortest_edge": 30}      )
              self.assertEqual(image_processor.crop_size							,   {"height": 30, "width": 30}      )

              UpperCamelCase       			=		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 						_SCREAMING_SNAKE_CASE							(	self			:				Union[str, Any]      )->	Any:







              """simple docstring"""
              pass






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







              """simple docstring"""
              # Initialize image_processing
              UpperCamelCase       			=		self.image_processing_class(**self.image_processor_dict      )
              # create random PIL images
              UpperCamelCase       			=		prepare_image_inputs(self.image_processor_tester							,   equal_resolution=UpperCAmelCase_      )
              for image in image_inputs:
                     self.assertIsInstance(UpperCAmelCase_							,   Image.Image      )

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






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[int]      )->	List[str]:







              """simple docstring"""
              # Initialize image_processing
              UpperCamelCase       			=		self.image_processing_class(**self.image_processor_dict      )
              # create random numpy tensors
              UpperCamelCase       			=		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
              UpperCamelCase       			=		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
              UpperCamelCase       			=		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.crop_size["height"],
                      self.image_processor_tester.crop_size["width"],
                  )							,   )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str      )->	str:







              """simple docstring"""
              # Initialize image_processing
              UpperCamelCase       			=		self.image_processing_class(**self.image_processor_dict      )
              # create random PyTorch tensors
              UpperCamelCase       			=		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
              UpperCamelCase       			=		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
              UpperCamelCase       			=		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.crop_size["height"],
                      self.image_processor_tester.crop_size["width"],
                  )							,   )





