




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     UpperCamelCase_   :

    '''simple docstring'''






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





           '''simple docstring'''

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

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


    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->Any:





           '''simple docstring'''

           A__							=   ids_tensor([self.batch_size, self.text_seq_length] ,			self.vocab_size)

           A__							=   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]:
                                A__							=   bbox[i, j, 3]
                                A__							=   bbox[i, j, 1]
                                A__							=   t
                         if bbox[i, j, 2] < bbox[i, j, 0]:
                                A__							=   bbox[i, j, 2]
                                A__							=   bbox[i, j, 0]
                                A__							=   t

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

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

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

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

           A__							=   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				:     Union[str, Any] ,			UpperCAmelCase__				:     str ,			UpperCAmelCase__				:     Dict ,			UpperCAmelCase__				:     Optional[int] ,			UpperCAmelCase__				:     int ,			UpperCAmelCase__				:     Optional[int] ,			UpperCAmelCase__				:     Dict ,			UpperCAmelCase__				:     Optional[Any] ,			UpperCAmelCase__				:     Any)						->str:





           '''simple docstring'''

           A__							=   LayoutLMvaModel(config=UpperCamelCase__)
           model.to(UpperCamelCase__)
           model.eval()

           # text + image
           A__							=   model(UpperCamelCase__ ,			pixel_values=UpperCamelCase__)
           A__							=   model(
               UpperCamelCase__ ,			bbox=UpperCamelCase__ ,			pixel_values=UpperCamelCase__ ,			attention_mask=UpperCamelCase__ ,			token_type_ids=UpperCamelCase__)
           A__							=   model(UpperCamelCase__ ,			bbox=UpperCamelCase__ ,			pixel_values=UpperCamelCase__ ,			token_type_ids=UpperCamelCase__)
           A__							=   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
           A__							=   model(UpperCamelCase__)
           self.parent.assertEqual(
               result.last_hidden_state.shape ,			(self.batch_size, self.text_seq_length, self.hidden_size))

           # image only
           A__							=   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				:     str ,			UpperCAmelCase__				:     List[str] ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     int ,			UpperCAmelCase__				:     Optional[Any] ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Dict ,			UpperCAmelCase__				:     str ,			UpperCAmelCase__				:     int)						->Optional[Any]:





           '''simple docstring'''

           A__							=   self.num_labels
           A__							=   LayoutLMvaForSequenceClassification(UpperCamelCase__)
           model.to(UpperCamelCase__)
           model.eval()
           A__							=   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				:     Optional[int] ,			UpperCAmelCase__				:     List[str] ,			UpperCAmelCase__				:     Optional[Any] ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Union[str, Any] ,			UpperCAmelCase__				:     int)						->str:





           '''simple docstring'''

           A__							=   self.num_labels
           A__							=   LayoutLMvaForTokenClassification(config=UpperCamelCase__)
           model.to(UpperCamelCase__)
           model.eval()
           A__							=   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__				:     Dict ,			UpperCAmelCase__				:     Optional[int] ,			UpperCAmelCase__				:     List[str] ,			UpperCAmelCase__				:     Optional[Any] ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     str ,			UpperCAmelCase__				:     str)						->int:





           '''simple docstring'''

           A__							=   LayoutLMvaForQuestionAnswering(config=UpperCamelCase__)
           model.to(UpperCamelCase__)
           model.eval()
           A__							=   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				:     Dict)						->int:





           '''simple docstring'''

           A__							=   self.prepare_config_and_inputs()
           (
               (
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							(
               A__     
           )			,							     
           )							=   config_and_inputs
           A__							=   {
               '''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     UpperCamelCase_   (			_snake_case		, _snake_case		, unittest.TestCase					):

    '''simple docstring'''






    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False

    UpperCAmelCase__							  =				(
        (
            LayoutLMvaModel,
            LayoutLMvaForSequenceClassification,
            LayoutLMvaForTokenClassification,
            LayoutLMvaForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    UpperCAmelCase__							  =				(
        {'''document-question-answering''': LayoutLMvaForQuestionAnswering, '''feature-extraction''': LayoutLMvaModel}
        if is_torch_available()
        else {}
    )


    def 	SCREAMING_SNAKE_CASE							(      self				:     Tuple ,			UpperCAmelCase__				:     Union[str, Any] ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     str ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     Any)						->Dict:





           '''simple docstring'''

           return True


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[str])						->str:





           '''simple docstring'''

           A__							=   LayoutLMvaModelTester(self)
           A__							=   ConfigTester(self ,			config_class=UpperCamelCase__ ,			hidden_size=37)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any] ,			UpperCAmelCase__				:     Union[str, Any] ,			UpperCAmelCase__				:     Tuple ,			UpperCAmelCase__				:     List[Any]=False)						->Union[str, Any]:





           '''simple docstring'''

           A__							=   copy.deepcopy(UpperCamelCase__)
           if model_class in get_values(UpperCamelCase__):
                  A__							=   {
                      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__):
                         A__							=   torch.ones(self.model_tester.batch_size ,			dtype=torch.long ,			device=UpperCamelCase__)
                  elif model_class in get_values(UpperCamelCase__):
                         A__							=   torch.zeros(
                             self.model_tester.batch_size ,			dtype=torch.long ,			device=UpperCamelCase__)
                         A__							=   torch.zeros(
                             self.model_tester.batch_size ,			dtype=torch.long ,			device=UpperCamelCase__)
                  elif model_class in [
                      *get_values(UpperCamelCase__),
                  ]:
                         A__							=   torch.zeros(
                             self.model_tester.batch_size ,			dtype=torch.long ,			device=UpperCamelCase__)
                  elif model_class in [
                      *get_values(UpperCamelCase__),
                  ]:
                         A__							=   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				:     Union[str, Any])						->Optional[Any]:





           '''simple docstring'''

           self.config_tester.run_common_tests()


    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->Dict:





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__)


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





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
                  A__							=   type
                  self.model_tester.create_and_check_model(*UpperCamelCase__)


    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->Dict:





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__)


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





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Tuple:





           '''simple docstring'''

           A__							=   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])						->Union[str, Any]:





           '''simple docstring'''

           for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A__							=   LayoutLMvaModel.from_pretrained(UpperCamelCase__)
                  self.assertIsNotNone(UpperCamelCase__)







def SCREAMING_SNAKE_CASE    (	)       ->	Dict:



       """simple docstring"""

       A__							=   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
       return image


@require_torch
class     UpperCamelCase_   (			unittest.TestCase					):

    '''simple docstring'''






    @cached_property
    def 	SCREAMING_SNAKE_CASE							(      self				:     List[Any])						->List[Any]:





           '''simple docstring'''

           return LayoutLMvaImageProcessor(apply_ocr=UpperCamelCase__) if is_vision_available() else None





    @slow
    def 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->Optional[Any]:





           '''simple docstring'''

           A__							=   LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base''').to(UpperCamelCase__)

           A__							=   self.default_image_processor
           A__							=   prepare_img()
           A__							=   image_processor(images=UpperCamelCase__ ,			return_tensors='''pt''').pixel_values.to(UpperCamelCase__)

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

           # forward pass
           A__							=   model(
               input_ids=input_ids.to(UpperCamelCase__) ,			bbox=bbox.to(UpperCamelCase__) ,			pixel_values=pixel_values.to(UpperCamelCase__) ,			)

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

           A__							=   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))







def SCREAMING_SNAKE_CASE    (	lowercase_ = 50						)       ->	int:



       """simple docstring"""

       A__							=   [1] * (length + 1)

       for row_length in range(3			,    length + 1						):
              for block_length in range(3			,    row_length + 1						):
                     for block_start in range(row_length - block_length						):
                            ways_number[row_length] += ways_number[
                                row_length - block_start - block_length - 1
                            ]

                     ways_number[row_length] += 1

       return ways_number[length]


if __name__ == "__main__":
  print(F'''{solution() = }''')


