





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]   ,    lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						Union[str, Any]=2   ,    lowerCAmelCase_					:						int=3   ,    lowerCAmelCase_					:						str=4   ,    lowerCAmelCase_					:						Any=2   ,    lowerCAmelCase_					:						List[Any]=7   ,    lowerCAmelCase_					:						Tuple=True   ,    lowerCAmelCase_					:						Any=True   ,    lowerCAmelCase_					:						Any=True   ,    lowerCAmelCase_					:						Dict=True   ,    lowerCAmelCase_					:						List[str]=9_9   ,    lowerCAmelCase_					:						Tuple=3_6   ,    lowerCAmelCase_					:						Optional[int]=3   ,    lowerCAmelCase_					:						Any=4   ,    lowerCAmelCase_					:						Optional[int]=3_7   ,    lowerCAmelCase_					:						List[Any]="gelu"   ,    lowerCAmelCase_					:						Dict=0.1   ,    lowerCAmelCase_					:						Optional[Any]=0.1   ,    lowerCAmelCase_					:						Optional[Any]=5_1_2   ,    lowerCAmelCase_					:						str=1_6   ,    lowerCAmelCase_					:						List[str]=2   ,    lowerCAmelCase_					:						Dict=0.02   ,    lowerCAmelCase_					:						Optional[Any]=6   ,    lowerCAmelCase_					:						Dict=6   ,    lowerCAmelCase_					:						Dict=3   ,    lowerCAmelCase_					:						List[Any]=4   ,    lowerCAmelCase_					:						List[Any]=None   ,    lowerCAmelCase_					:						str=1_0_0_0   ,    )				->		List[str]:
     __lowerCAmelCase				      =      parent
     __lowerCAmelCase				      =      batch_size
     __lowerCAmelCase				      =      num_channels
     __lowerCAmelCase				      =      image_size
     __lowerCAmelCase				      =      patch_size
     __lowerCAmelCase				      =      text_seq_length
     __lowerCAmelCase				      =      is_training
     __lowerCAmelCase				      =      use_input_mask
     __lowerCAmelCase				      =      use_token_type_ids
     __lowerCAmelCase				      =      use_labels
     __lowerCAmelCase				      =      vocab_size
     __lowerCAmelCase				      =      hidden_size
     __lowerCAmelCase				      =      num_hidden_layers
     __lowerCAmelCase				      =      num_attention_heads
     __lowerCAmelCase				      =      intermediate_size
     __lowerCAmelCase				      =      hidden_act
     __lowerCAmelCase				      =      hidden_dropout_prob
     __lowerCAmelCase				      =      attention_probs_dropout_prob
     __lowerCAmelCase				      =      max_position_embeddings
     __lowerCAmelCase				      =      type_vocab_size
     __lowerCAmelCase				      =      type_sequence_label_size
     __lowerCAmelCase				      =      initializer_range
     __lowerCAmelCase				      =      coordinate_size
     __lowerCAmelCase				      =      shape_size
     __lowerCAmelCase				      =      num_labels
     __lowerCAmelCase				      =      num_choices
     __lowerCAmelCase				      =      scope
     __lowerCAmelCase				      =      range_bbox

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






  def 							lowercase						(							self					:						str	)				->		Optional[int]:
     __lowerCAmelCase				      =      ids_tensor([self.batch_size, self.text_seq_length]   ,    self.vocab_size	)

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

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

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

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

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

     __lowerCAmelCase				      =      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 							lowercase						(							self					:						Optional[Any]   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						List[str]   ,    lowerCAmelCase_					:						str   ,    lowerCAmelCase_					:						Optional[int]   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						List[Any]	)				->		List[str]:
     __lowerCAmelCase				      =      LayoutLMvaModel(config=lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()

     # text + image
     __lowerCAmelCase				      =      model(lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_	)
     __lowerCAmelCase				      =      model(
         lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_   ,    attention_mask=lowerCAmelCase_   ,    token_type_ids=lowerCAmelCase_	)
     __lowerCAmelCase				      =      model(lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_   ,    token_type_ids=lowerCAmelCase_	)
     __lowerCAmelCase				      =      model(lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_	)

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

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

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






  def 							lowercase						(							self					:						int   ,    lowerCAmelCase_					:						Optional[int]   ,    lowerCAmelCase_					:						str   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						Any	)				->		Tuple:
     __lowerCAmelCase				      =      self.num_labels
     __lowerCAmelCase				      =      LayoutLMvaForSequenceClassification(lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()
     __lowerCAmelCase				      =      model(
         lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_   ,    attention_mask=lowerCAmelCase_   ,    token_type_ids=lowerCAmelCase_   ,    labels=lowerCAmelCase_   ,    )
     self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.num_labels)	)






  def 							lowercase						(							self					:						str   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						List[str]   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						int	)				->		Optional[Any]:
     __lowerCAmelCase				      =      self.num_labels
     __lowerCAmelCase				      =      LayoutLMvaForTokenClassification(config=lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()
     __lowerCAmelCase				      =      model(
         lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_   ,    attention_mask=lowerCAmelCase_   ,    token_type_ids=lowerCAmelCase_   ,    labels=lowerCAmelCase_   ,    )
     self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.text_seq_length, self.num_labels)	)






  def 							lowercase						(							self					:						Optional[int]   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						str   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						List[Any]   ,    lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						Optional[int]   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						int	)				->		Any:
     __lowerCAmelCase				      =      LayoutLMvaForQuestionAnswering(config=lowerCAmelCase_	)
     model.to(lowerCAmelCase_	)
     model.eval()
     __lowerCAmelCase				      =      model(
         lowerCAmelCase_   ,    bbox=lowerCAmelCase_   ,    pixel_values=lowerCAmelCase_   ,    attention_mask=lowerCAmelCase_   ,    token_type_ids=lowerCAmelCase_   ,    start_positions=lowerCAmelCase_   ,    end_positions=lowerCAmelCase_   ,    )
     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 							lowercase						(							self					:						Union[str, Any]	)				->		int:
     __lowerCAmelCase				      =      self.prepare_config_and_inputs()
     (
         (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,      (
         __lowerCAmelCase       
     )      ,             
     )				      =      config_and_inputs
     __lowerCAmelCase				      =      {
         '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       (       _UpperCamelCase						,       _UpperCamelCase						,       unittest.TestCase       ):

  """simple docstring"""


  a_              =					False
  a_              =					False
  a_              =					False

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






  def 							lowercase						(							self					:						str   ,    lowerCAmelCase_					:						Tuple   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						Optional[Any]   ,    lowerCAmelCase_					:						Any	)				->		Dict:
     return True






  def 							lowercase						(							self					:						int	)				->		Dict:
     __lowerCAmelCase				      =      LayoutLMvaModelTester(self	)
     __lowerCAmelCase				      =      ConfigTester(self   ,    config_class=lowerCAmelCase_   ,    hidden_size=3_7	)






  def 							lowercase						(							self					:						Optional[Any]   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						Any   ,    lowerCAmelCase_					:						List[str]=False	)				->		List[str]:
     __lowerCAmelCase				      =      copy.deepcopy(lowerCAmelCase_	)
     if model_class in get_values(lowerCAmelCase_	):
        __lowerCAmelCase				      =      {
            k: v.unsqueeze(1	).expand(-1   ,    self.model_tester.num_choices   ,    -1	).contiguous()
            if isinstance(lowerCAmelCase_   ,    torch.Tensor	) and v.ndim > 1
            else v
            for k, v in inputs_dict.items()
        }
     if return_labels:
        if model_class in get_values(lowerCAmelCase_	):
           __lowerCAmelCase				      =      torch.ones(self.model_tester.batch_size   ,    dtype=torch.long   ,    device=lowerCAmelCase_	)
        elif model_class in get_values(lowerCAmelCase_	):
           __lowerCAmelCase				      =      torch.zeros(
               self.model_tester.batch_size   ,    dtype=torch.long   ,    device=lowerCAmelCase_	)
           __lowerCAmelCase				      =      torch.zeros(
               self.model_tester.batch_size   ,    dtype=torch.long   ,    device=lowerCAmelCase_	)
        elif model_class in [
            *get_values(lowerCAmelCase_	),
        ]:
           __lowerCAmelCase				      =      torch.zeros(
               self.model_tester.batch_size   ,    dtype=torch.long   ,    device=lowerCAmelCase_	)
        elif model_class in [
            *get_values(lowerCAmelCase_	),
        ]:
           __lowerCAmelCase				      =      torch.zeros(
               (self.model_tester.batch_size, self.model_tester.text_seq_length)   ,    dtype=torch.long   ,    device=lowerCAmelCase_   ,    )

     return inputs_dict






  def 							lowercase						(							self					:						List[Any]	)				->		Dict:
     self.config_tester.run_common_tests()






  def 							lowercase						(							self					:						Tuple	)				->		Optional[Any]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase_	)






  def 							lowercase						(							self					:						List[str]	)				->		Tuple:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
        __lowerCAmelCase				      =      type
        self.model_tester.create_and_check_model(*lowerCAmelCase_	)






  def 							lowercase						(							self					:						Dict	)				->		List[str]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_	)






  def 							lowercase						(							self					:						Union[str, Any]	)				->		List[str]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_	)






  def 							lowercase						(							self					:						str	)				->		List[Any]:
     __lowerCAmelCase				      =      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_	)






  @slow
  def 							lowercase						(							self					:						Union[str, Any]	)				->		List[Any]:



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





def     a_       (					):
   __lowerCAmelCase				      =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
   return image




@require_torch
class 							_UpperCAmelCase       (       unittest.TestCase       ):

  """simple docstring"""


  @cached_property
  def 							lowercase						(							self					:						List[Any]	)				->		Optional[int]:
     return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase_	) if is_vision_available() else None






  @slow
  def 							lowercase						(							self					:						List[Any]	)				->		Any:
     __lowerCAmelCase				      =      LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'	).to(lowerCAmelCase_	)

     __lowerCAmelCase				      =      self.default_image_processor
     __lowerCAmelCase				      =      prepare_img()
     __lowerCAmelCase				      =      image_processor(images=lowerCAmelCase_   ,    return_tensors='pt'	).pixel_values.to(lowerCAmelCase_	)

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

     # forward pass
     __lowerCAmelCase				      =      model(
         input_ids=input_ids.to(lowerCAmelCase_	)   ,    bbox=bbox.to(lowerCAmelCase_	)   ,    pixel_values=pixel_values.to(lowerCAmelCase_	)   ,    )

     # verify the logits
     __lowerCAmelCase				      =      torch.Size((1, 1_9_9, 7_6_8)	)
     self.assertEqual(outputs.last_hidden_state.shape   ,    lowerCAmelCase_	)

     __lowerCAmelCase				      =      torch.tensor(
         [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]]	).to(lowerCAmelCase_	)

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






'''simple docstring'''





def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     if digit_amount > 0:
          return round(number - int(__A)    ,      __A)
     return number - int(__A)


if __name__ == "__main__":
  print(decimal_isolate(1.53, 0))
  print(decimal_isolate(35.345, 1))
  print(decimal_isolate(35.345, 2))
  print(decimal_isolate(35.345, 3))
  print(decimal_isolate(-14.789, 3))
  print(decimal_isolate(0, 2))
  print(decimal_isolate(-14.123, 1))
  print(decimal_isolate(-14.123, 2))
  print(decimal_isolate(-14.123, 3))



