






from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.layoutlm.modeling_tf_layoutlm import (
        TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLayoutLMForMaskedLM,
        TFLayoutLMForQuestionAnswering,
        TFLayoutLMForSequenceClassification,
        TFLayoutLMForTokenClassification,
        TFLayoutLMModel,
    )






class 					SCREAMING_SNAKE_CASE_  :
       """simple docstring"""


       def __init__(				self	:str,      snake_case	:List[str],      snake_case	:int=13,      snake_case	:Dict=7,      snake_case	:Optional[Any]=True,      snake_case	:List[Any]=True,      snake_case	:Optional[int]=True,      snake_case	:Tuple=True,      snake_case	:Any=99,      snake_case	:Optional[int]=32,      snake_case	:Optional[Any]=2,      snake_case	:Dict=4,      snake_case	:Optional[int]=37,      snake_case	:Union[str, Any]="gelu",      snake_case	:Tuple=0.1,      snake_case	:Union[str, Any]=0.1,      snake_case	:List[str]=512,      snake_case	:Optional[int]=16,      snake_case	:int=2,      snake_case	:Tuple=0.0_2,      snake_case	:str=3,      snake_case	:Optional[Any]=4,      snake_case	:Union[str, Any]=None,      snake_case	:Dict=1000,      ):



          """simple docstring"""

          _lowercase              =parent
          _lowercase              =batch_size
          _lowercase              =seq_length
          _lowercase              =is_training
          _lowercase              =use_input_mask
          _lowercase              =use_token_type_ids
          _lowercase              =use_labels
          _lowercase              =vocab_size
          _lowercase              =hidden_size
          _lowercase              =num_hidden_layers
          _lowercase              =num_attention_heads
          _lowercase              =intermediate_size
          _lowercase              =hidden_act
          _lowercase              =hidden_dropout_prob
          _lowercase              =attention_probs_dropout_prob
          _lowercase              =max_position_embeddings
          _lowercase              =type_vocab_size
          _lowercase              =type_sequence_label_size
          _lowercase              =initializer_range
          _lowercase              =num_labels
          _lowercase              =num_choices
          _lowercase              =scope
          _lowercase              =range_bbox





       def 				UpperCamelCase__						(				self	:Any):



          """simple docstring"""

          _lowercase              =ids_tensor([self.batch_size, self.seq_length],      self.vocab_size)

          # convert bbox to numpy since TF does not support item assignment
          _lowercase              =ids_tensor([self.batch_size, self.seq_length, 4],      self.range_bbox).numpy()
          # 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]:
                   _lowercase              =bbox[i, j, 3]
                   _lowercase              =bbox[i, j, 1]
                   _lowercase              =t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                   _lowercase              =bbox[i, j, 2]
                   _lowercase              =bbox[i, j, 0]
                   _lowercase              =t
          _lowercase              =tf.convert_to_tensor(snake_case)

          _lowercase              =None
          if self.use_input_mask:
             _lowercase              =random_attention_mask([self.batch_size, self.seq_length])

          _lowercase              =None
          if self.use_token_type_ids:
             _lowercase              =ids_tensor([self.batch_size, self.seq_length],      self.type_vocab_size)

          _lowercase              =None
          _lowercase              =None
          _lowercase              =None
          if self.use_labels:
             _lowercase              =ids_tensor([self.batch_size],      self.type_sequence_label_size)
             _lowercase              =ids_tensor([self.batch_size, self.seq_length],      self.num_labels)
             _lowercase              =ids_tensor([self.batch_size],      self.num_choices)

          _lowercase              =LayoutLMConfig(
              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,      )

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





       def 				UpperCamelCase__						(				self	:Tuple,      snake_case	:int,      snake_case	:str,      snake_case	:Union[str, Any],      snake_case	:str,      snake_case	:int,      snake_case	:Any,      snake_case	:Optional[int],      snake_case	:Dict):



          """simple docstring"""

          _lowercase              =TFLayoutLMModel(config=snake_case)

          _lowercase              =model(snake_case,      snake_case,      attention_mask=snake_case,      token_type_ids=snake_case)
          _lowercase              =model(snake_case,      snake_case,      token_type_ids=snake_case)
          _lowercase              =model(snake_case,      snake_case)
          self.parent.assertEqual(result.last_hidden_state.shape,      (self.batch_size, self.seq_length, self.hidden_size))
          self.parent.assertEqual(result.pooler_output.shape,      (self.batch_size, self.hidden_size))





       def 				UpperCamelCase__						(				self	:int,      snake_case	:str,      snake_case	:int,      snake_case	:Optional[int],      snake_case	:List[Any],      snake_case	:Any,      snake_case	:Union[str, Any],      snake_case	:Tuple,      snake_case	:Union[str, Any]):



          """simple docstring"""

          _lowercase              =TFLayoutLMForMaskedLM(config=snake_case)

          _lowercase              =model(snake_case,      snake_case,      attention_mask=snake_case,      token_type_ids=snake_case,      labels=snake_case)
          self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.vocab_size))





       def 				UpperCamelCase__						(				self	:List[Any],      snake_case	:Dict,      snake_case	:Union[str, Any],      snake_case	:Union[str, Any],      snake_case	:Union[str, Any],      snake_case	:str,      snake_case	:List[str],      snake_case	:int,      snake_case	:int):



          """simple docstring"""

          _lowercase              =self.num_labels
          _lowercase              =TFLayoutLMForSequenceClassification(config=snake_case)

          _lowercase              =model(snake_case,      snake_case,      attention_mask=snake_case,      token_type_ids=snake_case)
          self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_labels))





       def 				UpperCamelCase__						(				self	:int,      snake_case	:Any,      snake_case	:Optional[Any],      snake_case	:Dict,      snake_case	:List[str],      snake_case	:Tuple,      snake_case	:Dict,      snake_case	:List[str],      snake_case	:Dict):



          """simple docstring"""

          _lowercase              =self.num_labels
          _lowercase              =TFLayoutLMForTokenClassification(config=snake_case)

          _lowercase              =model(snake_case,      snake_case,      attention_mask=snake_case,      token_type_ids=snake_case,      labels=snake_case)
          self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.num_labels))





       def 				UpperCamelCase__						(				self	:Union[str, Any],      snake_case	:Dict,      snake_case	:Optional[int],      snake_case	:List[str],      snake_case	:Optional[int],      snake_case	:List[str],      snake_case	:Optional[Any],      snake_case	:str,      snake_case	:Any):



          """simple docstring"""

          _lowercase              =TFLayoutLMForQuestionAnswering(config=snake_case)

          _lowercase              =model(snake_case,      snake_case,      attention_mask=snake_case,      token_type_ids=snake_case)
          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 				UpperCamelCase__						(				self	:Tuple):



          """simple docstring"""

          _lowercase              =self.prepare_config_and_inputs()
          (
              (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       (
              _lowercase
          )       ,       
          )              =config_and_inputs
          _lowercase              ={
              'input_ids': input_ids,
              'bbox': bbox,
              'token_type_ids': token_type_ids,
              'attention_mask': input_mask,
          }
          return config, inputs_dict






@require_tf
class 					SCREAMING_SNAKE_CASE_  (       _a  ,						_a  ,						unittest.TestCase ):
       """simple docstring"""


       __lowerCAmelCase    :		str					=(
           (
               TFLayoutLMModel,
               TFLayoutLMForMaskedLM,
               TFLayoutLMForTokenClassification,
               TFLayoutLMForSequenceClassification,
               TFLayoutLMForQuestionAnswering,
           )
           if is_tf_available()
           else ()
       )
       __lowerCAmelCase    :		str					=(
           {
               '''feature-extraction''': TFLayoutLMModel,
               '''fill-mask''': TFLayoutLMForMaskedLM,
               '''text-classification''': TFLayoutLMForSequenceClassification,
               '''token-classification''': TFLayoutLMForTokenClassification,
               '''zero-shot''': TFLayoutLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowerCAmelCase    :		Optional[Any]					=False
       __lowerCAmelCase    :		Optional[Any]					=True
       __lowerCAmelCase    :		Dict					=1_0





       def 				UpperCamelCase__						(				self	:Optional[Any]):



          """simple docstring"""

          _lowercase              =TFLayoutLMModelTester(self)
          _lowercase              =ConfigTester(self,      config_class=snake_case,      hidden_size=37)





       def 				UpperCamelCase__						(				self	:Optional[Any]):



          """simple docstring"""

          self.config_tester.run_common_tests()





       def 				UpperCamelCase__						(				self	:Optional[int]):



          """simple docstring"""

          _lowercase              =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case)





       def 				UpperCamelCase__						(				self	:Optional[Any]):



          """simple docstring"""

          _lowercase              =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*snake_case)





       def 				UpperCamelCase__						(				self	:Tuple):



          """simple docstring"""

          _lowercase              =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*snake_case)





       def 				UpperCamelCase__						(				self	:Union[str, Any]):



          """simple docstring"""

          _lowercase              =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*snake_case)





       def 				UpperCamelCase__						(				self	:List[Any]):



          """simple docstring"""

          _lowercase              =self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*snake_case)





       @slow
       def 				UpperCamelCase__						(				self	:Union[str, Any]):



          """simple docstring"""

          for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _lowercase              =TFLayoutLMModel.from_pretrained(snake_case)
             self.assertIsNotNone(snake_case)





       @unittest.skip('Onnx compliancy broke with TF 2.10')
       def 				UpperCamelCase__						(				self	:List[str]):



          """simple docstring"""

          pass





def        _snake_case   ()					->	Dict:
   # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
   # fmt: off
   _lowercase              =tf.convert_to_tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]])  # noqa: E231
   _lowercase              =tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],])  # noqa: E231
   _lowercase              =tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]])  # noqa: E231
   _lowercase              =tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]])  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   _lowercase              =tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]])  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class 					SCREAMING_SNAKE_CASE_  (       unittest.TestCase ):
       """simple docstring"""


       @slow
       def 				UpperCamelCase__						(				self	:Optional[Any]):



          """simple docstring"""

          _lowercase              =TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased')

          _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase              =prepare_layoutlm_batch_inputs()

          # forward pass
          _lowercase              =model(input_ids=snake_case,      bbox=snake_case,      attention_mask=snake_case,      token_type_ids=snake_case)

          # test the sequence output on [0, :3, :3]
          _lowercase              =tf.convert_to_tensor(
              [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]],      )

          self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3],      snake_case,      atol=1e-3))

          # test the pooled output on [1, :3]
          _lowercase              =tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2])

          self.assertTrue(np.allclose(outputs.pooler_output[1, :3],      snake_case,      atol=1e-3))





       @slow
       def 				UpperCamelCase__						(				self	:Optional[int]):



          """simple docstring"""

          _lowercase              =TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased',      num_labels=2)

          _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase              =prepare_layoutlm_batch_inputs()

          # forward pass
          _lowercase              =model(
              input_ids=snake_case,      bbox=snake_case,      attention_mask=snake_case,      token_type_ids=snake_case,      labels=tf.convert_to_tensor([1, 1]),      )

          # test whether we get a loss as a scalar
          _lowercase              =outputs.loss
          _lowercase              =(2,)
          self.assertEqual(loss.shape,      snake_case)

          # test the shape of the logits
          _lowercase              =outputs.logits
          _lowercase              =(2, 2)
          self.assertEqual(logits.shape,      snake_case)





       @slow
       def 				UpperCamelCase__						(				self	:str):



          """simple docstring"""

          _lowercase              =TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased',      num_labels=13)

          _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase              =prepare_layoutlm_batch_inputs()

          # forward pass
          _lowercase              =model(
              input_ids=snake_case,      bbox=snake_case,      attention_mask=snake_case,      token_type_ids=snake_case,      labels=snake_case)

          # test the shape of the logits
          _lowercase              =outputs.logits
          _lowercase              =tf.convert_to_tensor((2, 25, 13))
          self.assertEqual(logits.shape,      snake_case)





       @slow
       def 				UpperCamelCase__						(				self	:Union[str, Any]):



          """simple docstring"""

          _lowercase              =TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased')

          _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase       ,       _lowercase              =prepare_layoutlm_batch_inputs()

          # forward pass
          _lowercase              =model(input_ids=snake_case,      bbox=snake_case,      attention_mask=snake_case,      token_type_ids=snake_case)

          # test the shape of the logits
          _lowercase              =tf.convert_to_tensor((2, 25))
          self.assertEqual(outputs.start_logits.shape,      snake_case)
          self.assertEqual(outputs.end_logits.shape,      snake_case)










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


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ChineseCLIPImageProcessor






class 					SCREAMING_SNAKE_CASE_  (       unittest.TestCase ):
       """simple docstring"""


       def __init__(				self	:Any,      snake_case	:Optional[int],      snake_case	:Optional[Any]=7,      snake_case	:str=3,      snake_case	:Optional[int]=18,      snake_case	:str=30,      snake_case	:List[Any]=400,      snake_case	:Any=True,      snake_case	:Dict=None,      snake_case	:Any=True,      snake_case	:Dict=None,      snake_case	:List[Any]=True,      snake_case	:Optional[int]=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],      snake_case	:Any=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],      snake_case	:int=True,      ):



          """simple docstring"""

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





       def 				UpperCamelCase__						(				self	:Any):



          """simple docstring"""

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





       def 				UpperCamelCase__						(				self	:Dict,      snake_case	:List[Any]=False,      snake_case	:Any=False,      snake_case	:Union[str, Any]=False):



          """simple docstring"""

          assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

          if equal_resolution:
             _lowercase              =[]
             for i in range(self.batch_size):
                image_inputs.append(
                    np.random.randint(
                        255,      size=(self.num_channels, self.max_resolution, self.max_resolution),      dtype=np.uinta))
          else:
             _lowercase              =[]
             for i in range(self.batch_size):
                _lowercase       ,       _lowercase              =np.random.choice(np.arange(self.min_resolution,      self.max_resolution),      2)
                image_inputs.append(np.random.randint(255,      size=(self.num_channels, width, height),      dtype=np.uinta))

          if not numpify and not torchify:
             # PIL expects the channel dimension as last dimension
             _lowercase              =[Image.fromarray(np.moveaxis(snake_case,      0,      -1)) for x in image_inputs]

          if torchify:
             _lowercase              =[torch.from_numpy(snake_case) for x in image_inputs]

          return image_inputs






@require_torch
@require_vision
class 					SCREAMING_SNAKE_CASE_  (       _a  ,						unittest.TestCase ):
       """simple docstring"""


       __lowerCAmelCase    :		List[Any]					=ChineseCLIPImageProcessor if is_vision_available() else None





       def 				UpperCamelCase__						(				self	:Dict):



          """simple docstring"""

          _lowercase              =ChineseCLIPImageProcessingTester(self,      do_center_crop=snake_case)





       @property
       def 				UpperCamelCase__						(				self	:Dict):



          """simple docstring"""

          return self.image_processor_tester.prepare_image_processor_dict()





       def 				UpperCamelCase__						(				self	:Optional[int]):



          """simple docstring"""

          _lowercase              =self.image_processing_class(**self.image_processor_dict)
          self.assertTrue(hasattr(snake_case,      'do_resize'))
          self.assertTrue(hasattr(snake_case,      'size'))
          self.assertTrue(hasattr(snake_case,      'do_center_crop'))
          self.assertTrue(hasattr(snake_case,      'center_crop'))
          self.assertTrue(hasattr(snake_case,      'do_normalize'))
          self.assertTrue(hasattr(snake_case,      'image_mean'))
          self.assertTrue(hasattr(snake_case,      'image_std'))
          self.assertTrue(hasattr(snake_case,      'do_convert_rgb'))





       def 				UpperCamelCase__						(				self	:List[str]):



          """simple docstring"""

          _lowercase              =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': 18, 'width': 18})

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



          """simple docstring"""

          pass





       def 				UpperCamelCase__						(				self	:Any):



          """simple docstring"""

          _lowercase              =self.image_processing_class(**self.image_processor_dict)
          # create random PIL images
          _lowercase              =self.image_processor_tester.prepare_inputs(equal_resolution=snake_case)
          for image in image_inputs:
             self.assertIsInstance(snake_case,      Image.Image)

          # Test not batched input
          _lowercase              =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
          _lowercase              =image_processing(snake_case,      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	:List[str]):



          """simple docstring"""

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

          # Test not batched input
          _lowercase              =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
          _lowercase              =image_processing(snake_case,      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"""

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

          # Test not batched input
          _lowercase              =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
          _lowercase              =image_processing(snake_case,      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'],
              ),      )






@require_torch
@require_vision
class 					SCREAMING_SNAKE_CASE_  (       _a  ,						unittest.TestCase ):
       """simple docstring"""


       __lowerCAmelCase    :		Optional[Any]					=ChineseCLIPImageProcessor if is_vision_available() else None





       def 				UpperCamelCase__						(				self	:Dict):



          """simple docstring"""

          _lowercase              =ChineseCLIPImageProcessingTester(self,      num_channels=4,      do_center_crop=snake_case)
          _lowercase              =3





       @property
       def 				UpperCamelCase__						(				self	:Tuple):



          """simple docstring"""

          return self.image_processor_tester.prepare_image_processor_dict()





       def 				UpperCamelCase__						(				self	:Tuple):



          """simple docstring"""

          _lowercase              =self.image_processing_class(**self.image_processor_dict)
          self.assertTrue(hasattr(snake_case,      'do_resize'))
          self.assertTrue(hasattr(snake_case,      'size'))
          self.assertTrue(hasattr(snake_case,      'do_center_crop'))
          self.assertTrue(hasattr(snake_case,      'center_crop'))
          self.assertTrue(hasattr(snake_case,      'do_normalize'))
          self.assertTrue(hasattr(snake_case,      'image_mean'))
          self.assertTrue(hasattr(snake_case,      'image_std'))
          self.assertTrue(hasattr(snake_case,      'do_convert_rgb'))





       def 				UpperCamelCase__						(				self	:Dict):



          """simple docstring"""

          pass





       def 				UpperCamelCase__						(				self	:str):



          """simple docstring"""

          _lowercase              =self.image_processing_class(**self.image_processor_dict)
          # create random PIL images
          _lowercase              =self.image_processor_tester.prepare_inputs(equal_resolution=snake_case)
          for image in image_inputs:
             self.assertIsInstance(snake_case,      Image.Image)

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

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


