


from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

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


if is_tf_available():
   import tensorflow as tf

   from transformers import (
       TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
       TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
       TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
       TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
       LayoutLMvaConfig,
       TFLayoutLMvaForQuestionAnswering,
       TFLayoutLMvaForSequenceClassification,
       TFLayoutLMvaForTokenClassification,
       TFLayoutLMvaModel,
   )

if is_vision_available():
   from PIL import Image

   from transformers import LayoutLMvaImageProcessor







class lowerCAmelCase_		:

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase	,   _UpperCAmelCase=2	,   _UpperCAmelCase=3	,   _UpperCAmelCase=4	,   _UpperCAmelCase=2	,   _UpperCAmelCase=7	,   _UpperCAmelCase=True	,   _UpperCAmelCase=True	,   _UpperCAmelCase=True	,   _UpperCAmelCase=True	,   _UpperCAmelCase=99	,   _UpperCAmelCase=36	,   _UpperCAmelCase=2	,   _UpperCAmelCase=4	,   _UpperCAmelCase=37	,   _UpperCAmelCase="gelu"	,   _UpperCAmelCase=0.1	,   _UpperCAmelCase=0.1	,   _UpperCAmelCase=5_12	,   _UpperCAmelCase=16	,   _UpperCAmelCase=2	,   _UpperCAmelCase=0.02	,   _UpperCAmelCase=6	,   _UpperCAmelCase=6	,   _UpperCAmelCase=3	,   _UpperCAmelCase=4	,   _UpperCAmelCase=None	,   _UpperCAmelCase=10_00	,   ):
       snake_case_ =   parent
       snake_case_ =   batch_size
       snake_case_ =   num_channels
       snake_case_ =   image_size
       snake_case_ =   patch_size
       snake_case_ =   is_training
       snake_case_ =   use_input_mask
       snake_case_ =   use_token_type_ids
       snake_case_ =   use_labels
       snake_case_ =   vocab_size
       snake_case_ =   hidden_size
       snake_case_ =   num_hidden_layers
       snake_case_ =   num_attention_heads
       snake_case_ =   intermediate_size
       snake_case_ =   hidden_act
       snake_case_ =   hidden_dropout_prob
       snake_case_ =   attention_probs_dropout_prob
       snake_case_ =   max_position_embeddings
       snake_case_ =   type_vocab_size
       snake_case_ =   type_sequence_label_size
       snake_case_ =   initializer_range
       snake_case_ =   coordinate_size
       snake_case_ =   shape_size
       snake_case_ =   num_labels
       snake_case_ =   num_choices
       snake_case_ =   scope
       snake_case_ =   range_bbox

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



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   ids_tensor([self.batch_size, self.text_seq_length]	,   self.vocab_size      )

       snake_case_ =   ids_tensor([self.batch_size, self.text_seq_length, 4]	,   self.range_bbox      )
       snake_case_ =   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]:
                         snake_case_ =   bbox[i, j, 3]
                         snake_case_ =   bbox[i, j, 1]
                         snake_case_ =   tmp_coordinate
                   if bbox[i, j, 2] < bbox[i, j, 0]:
                         snake_case_ =   bbox[i, j, 2]
                         snake_case_ =   bbox[i, j, 0]
                         snake_case_ =   tmp_coordinate
       snake_case_ =   tf.constant(_UpperCAmelCase      )

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

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

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

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

       snake_case_ =   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 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       snake_case_ =   TFLayoutLMvaModel(config=_UpperCAmelCase      )

       # text + image
       snake_case_ =   model(_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   training=_UpperCAmelCase      )
       snake_case_ =   model(
           _UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   attention_mask=_UpperCAmelCase	,   token_type_ids=_UpperCAmelCase	,   training=_UpperCAmelCase	,   )
       snake_case_ =   model(_UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   training=_UpperCAmelCase      )

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

       # text only
       snake_case_ =   model(_UpperCAmelCase	,   training=_UpperCAmelCase      )
       self.parent.assertEqual(
           result.last_hidden_state.shape	,   (self.batch_size, self.text_seq_length, self.hidden_size)      )

       # image only
       snake_case_ =   model({'''pixel_values''': pixel_values}	,   training=_UpperCAmelCase      )
       self.parent.assertEqual(
           result.last_hidden_state.shape	,   (self.batch_size, self.image_seq_length, self.hidden_size)      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       snake_case_ =   self.num_labels
       snake_case_ =   TFLayoutLMvaForSequenceClassification(config=_UpperCAmelCase      )
       snake_case_ =   model(
           _UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   attention_mask=_UpperCAmelCase	,   token_type_ids=_UpperCAmelCase	,   labels=_UpperCAmelCase	,   training=_UpperCAmelCase	,   )
       self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       snake_case_ =   self.num_labels
       snake_case_ =   TFLayoutLMvaForTokenClassification(config=_UpperCAmelCase      )
       snake_case_ =   model(
           _UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   attention_mask=_UpperCAmelCase	,   token_type_ids=_UpperCAmelCase	,   labels=_UpperCAmelCase	,   training=_UpperCAmelCase	,   )
       self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.text_seq_length, self.num_labels)      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       snake_case_ =   2
       snake_case_ =   TFLayoutLMvaForQuestionAnswering(config=_UpperCAmelCase      )
       snake_case_ =   model(
           _UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   attention_mask=_UpperCAmelCase	,   token_type_ids=_UpperCAmelCase	,   start_positions=_UpperCAmelCase	,   end_positions=_UpperCAmelCase	,   training=_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 		UpperCamelCase__  (			self      ):
       snake_case_ =   self.prepare_config_and_inputs()
       (snake_case_) =   config_and_inputs
       snake_case_ =   {
           """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_tf
class lowerCAmelCase_		(				UpperCAmelCase__      ,		UpperCAmelCase__      ,		unittest.TestCase ):

 '''simple docstring'''

 __snake_case				=						(
     (
         TFLayoutLMvaModel,
         TFLayoutLMvaForQuestionAnswering,
         TFLayoutLMvaForSequenceClassification,
         TFLayoutLMvaForTokenClassification,
     )
     if is_tf_available()
     else ()
 )
 __snake_case				=						(
     {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
     if is_tf_available()
     else {}
 )

 __snake_case				=						False
 __snake_case				=						False
 __snake_case				=						False



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
       return True



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase=False      ):
       snake_case_ =   copy.deepcopy(_UpperCAmelCase      )

       if model_class in get_values(_UpperCAmelCase      ):
             snake_case_ =   {
                 k: tf.tile(tf.expand_dims(_UpperCAmelCase	,   1      )	,   (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)      )
                 if isinstance(_UpperCAmelCase	,   tf.Tensor      ) and v.ndim > 0
                 else v
                 for k, v in inputs_dict.items()
             }

       if return_labels:
             if model_class in get_values(_UpperCAmelCase      ):
                   snake_case_ =   tf.ones(self.model_tester.batch_size	,   dtype=tf.intaa      )
             elif model_class in get_values(_UpperCAmelCase      ):
                   snake_case_ =   tf.zeros(self.model_tester.batch_size	,   dtype=tf.intaa      )
                   snake_case_ =   tf.zeros(self.model_tester.batch_size	,   dtype=tf.intaa      )
             elif model_class in get_values(_UpperCAmelCase      ):
                   snake_case_ =   tf.zeros(self.model_tester.batch_size	,   dtype=tf.intaa      )
             elif model_class in get_values(_UpperCAmelCase      ):
                   snake_case_ =   tf.zeros(
                       (self.model_tester.batch_size, self.model_tester.text_seq_length)	,   dtype=tf.intaa      )

       return inputs_dict



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   TFLayoutLMvaModelTester(self      )
       snake_case_ =   ConfigTester(self	,   config_class=_UpperCAmelCase	,   hidden_size=37      )



 def 		UpperCamelCase__  (			self      ):
       self.config_tester.run_common_tests()



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes:
             snake_case_ =   model_class(_UpperCAmelCase      )
             if getattr(_UpperCAmelCase	,   '''hf_compute_loss'''	,   _UpperCAmelCase      ):
                   # The number of elements in the loss should be the same as the number of elements in the label
                   snake_case_ =   self._prepare_for_class(inputs_dict.copy()	,   _UpperCAmelCase	,   return_labels=_UpperCAmelCase      )
                   snake_case_ =   prepared_for_class[
                       sorted(prepared_for_class.keys() - inputs_dict.keys()	,   reverse=_UpperCAmelCase      )[0]
                   ]
                   snake_case_ =   added_label.shape.as_list()[:1]

                   # Test that model correctly compute the loss with kwargs
                   snake_case_ =   self._prepare_for_class(inputs_dict.copy()	,   _UpperCAmelCase	,   return_labels=_UpperCAmelCase      )
                   snake_case_ =   prepared_for_class.pop('''input_ids'''      )

                   snake_case_ =   model(_UpperCAmelCase	,   **_UpperCAmelCase      )[0]
                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]      )

                   # Test that model correctly compute the loss when we mask some positions
                   snake_case_ =   self._prepare_for_class(inputs_dict.copy()	,   _UpperCAmelCase	,   return_labels=_UpperCAmelCase      )
                   snake_case_ =   prepared_for_class.pop('''input_ids'''      )
                   if "labels" in prepared_for_class:
                         snake_case_ =   prepared_for_class["""labels"""].numpy()
                         if len(labels.shape      ) > 1 and labels.shape[1] != 1:
                               snake_case_ =   -1_00
                               snake_case_ =   tf.convert_to_tensor(_UpperCAmelCase      )
                               snake_case_ =   model(_UpperCAmelCase	,   **_UpperCAmelCase      )[0]
                               self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]      )
                               self.assertTrue(not np.any(np.isnan(loss.numpy()      )      )      )

                           # Test that model correctly compute the loss with a dict
                   snake_case_ =   self._prepare_for_class(inputs_dict.copy()	,   _UpperCAmelCase	,   return_labels=_UpperCAmelCase      )
                   snake_case_ =   model(_UpperCAmelCase      )[0]
                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]      )

                   # Test that model correctly compute the loss with a tuple
                   snake_case_ =   self._prepare_for_class(inputs_dict.copy()	,   _UpperCAmelCase	,   return_labels=_UpperCAmelCase      )

                   # Get keys that were added with the _prepare_for_class function
                   snake_case_ =   prepared_for_class.keys() - inputs_dict.keys()
                   snake_case_ =   inspect.signature(model.call      ).parameters
                   snake_case_ =   list(signature.keys()      )

                   # Create a dictionary holding the location of the tensors in the tuple
                   snake_case_ =   {0: """input_ids"""}
                   for label_key in label_keys:
                         snake_case_ =   signature_names.index(_UpperCAmelCase      )
                         snake_case_ =   label_key
                   snake_case_ =   sorted(tuple_index_mapping.items()      )
                   # Initialize a list with their default values, update the values and convert to a tuple
                   snake_case_ =   []

                   for name in signature_names:
                         if name != "kwargs":
                               list_input.append(signature[name].default      )

                   for index, value in sorted_tuple_index_mapping:
                         snake_case_ =   prepared_for_class[value]

                   snake_case_ =   tuple(_UpperCAmelCase      )

                   # Send to model
                   snake_case_ =   model(tuple_input[:-1]      )[0]

                   self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]      )



 def 		UpperCamelCase__  (			self      ):
       (
           snake_case_		
       ) =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      )



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



 def 		UpperCamelCase__  (			self      ):
       (
           snake_case_		
       ) =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(
           _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       (
           snake_case_		
       ) =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(
           _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      )



 def 		UpperCamelCase__  (			self      ):
       (
           snake_case_		
       ) =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(
           _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      )





 @slow
 def 		UpperCamelCase__  (			self      ):




       for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case_ =   TFLayoutLMvaModel.from_pretrained(_UpperCAmelCase      )
             self.assertIsNotNone(_UpperCAmelCase      )






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




      """simple docstring"""

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







@require_tf
class lowerCAmelCase_		(				unittest.TestCase ):

 '''simple docstring'''

 @cached_property
 def 		UpperCamelCase__  (			self      ):
       return LayoutLMvaImageProcessor(apply_ocr=_UpperCAmelCase      ) if is_vision_available() else None





 @slow
 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   TFLayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''      )

       snake_case_ =   self.default_image_processor
       snake_case_ =   prepare_img()
       snake_case_ =   image_processor(images=_UpperCAmelCase	,   return_tensors='''tf'''      ).pixel_values

       snake_case_ =   tf.constant([[1, 2]]      )
       snake_case_ =   tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]]      )	,   axis=0      )

       # forward pass
       snake_case_ =   model(input_ids=_UpperCAmelCase	,   bbox=_UpperCAmelCase	,   pixel_values=_UpperCAmelCase	,   training=_UpperCAmelCase      )

       # verify the logits
       snake_case_ =   (1, 1_99, 7_68)
       self.assertEqual(outputs.last_hidden_state.shape	,   _UpperCAmelCase      )

       snake_case_ =   tf.constant(
           [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]      )

       self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]	,   _UpperCAmelCase	,   atol=1E-4      )      )



def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE = 6008_5147_5143      )->						int:




      """simple docstring"""

      try:
            snake_case_ =   int(SCREAMING_SNAKE_CASE      )
      except (TypeError, ValueError):
            raise TypeError('''Parameter n must be int or castable to int.'''      )
      if n <= 0:
            raise ValueError('''Parameter n must be greater than or equal to one.'''      )
      snake_case_ =   1
      snake_case_ =   2
      while i * i <= n:
            while n % i == 0:
                  snake_case_ =   i
                  n //= i
            i += 1
      if n > 1:
            snake_case_ =   n
      return int(SCREAMING_SNAKE_CASE      )


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