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



      """simple docstring"""







      def __init__(      self		:       List[Any]				,       _snake_case		:       Tuple				,       _snake_case		:       str=13				,       _snake_case		:       List[Any]=7				,       _snake_case		:       Optional[int]=True				,       _snake_case		:       Any=True				,       _snake_case		:       Optional[Any]=True				,       _snake_case		:       Optional[int]=True				,       _snake_case		:       int=99				,       _snake_case		:       Any=32				,       _snake_case		:       Any=2				,       _snake_case		:       Optional[Any]=4				,       _snake_case		:       List[Any]=37				,       _snake_case		:       Union[str, Any]="gelu"				,       _snake_case		:       str=0.1				,       _snake_case		:       List[Any]=0.1				,       _snake_case		:       Any=512				,       _snake_case		:       List[Any]=16				,       _snake_case		:       Union[str, Any]=2				,       _snake_case		:       str=0.02				,       _snake_case		:       Any=3				,       _snake_case		:       Dict=4				,       _snake_case		:       Optional[int]=None				,       _snake_case		:       Tuple=1000				,       ):
          __lowercase		:			str	    =       parent
          __lowercase		:			List[Any]	    =       batch_size
          __lowercase		:			Any	    =       seq_length
          __lowercase		:			Tuple	    =       is_training
          __lowercase		:			List[str]	    =       use_input_mask
          __lowercase		:			Dict	    =       use_token_type_ids
          __lowercase		:			Optional[int]	    =       use_labels
          __lowercase		:			Tuple	    =       vocab_size
          __lowercase		:			Dict	    =       hidden_size
          __lowercase		:			Any	    =       num_hidden_layers
          __lowercase		:			Dict	    =       num_attention_heads
          __lowercase		:			List[str]	    =       intermediate_size
          __lowercase		:			Tuple	    =       hidden_act
          __lowercase		:			List[str]	    =       hidden_dropout_prob
          __lowercase		:			List[str]	    =       attention_probs_dropout_prob
          __lowercase		:			Any	    =       max_position_embeddings
          __lowercase		:			Optional[Any]	    =       type_vocab_size
          __lowercase		:			Dict	    =       type_sequence_label_size
          __lowercase		:			Optional[Any]	    =       initializer_range
          __lowercase		:			Union[str, Any]	    =       num_labels
          __lowercase		:			Any	    =       num_choices
          __lowercase		:			Tuple	    =       scope
          __lowercase		:			Union[str, Any]	    =       range_bbox




      def 		snake_case_			(      self		:       Dict				):
          __lowercase		:			Tuple	    =       ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size				)

          # convert bbox to numpy since TF does not support item assignment
          __lowercase		:			Optional[Any]	    =       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		:			Tuple	    =       bbox[i, j, 3]
                      __lowercase		:			List[str]	    =       bbox[i, j, 1]
                      __lowercase		:			Tuple	    =       t
                  if bbox[i, j, 2] < bbox[i, j, 0]:
                      __lowercase		:			int	    =       bbox[i, j, 2]
                      __lowercase		:			List[str]	    =       bbox[i, j, 0]
                      __lowercase		:			Any	    =       t
          __lowercase		:			Optional[int]	    =       tf.convert_to_tensor(_snake_case				)

          __lowercase		:			Optional[Any]	    =       None
          if self.use_input_mask:
              __lowercase		:			Any	    =       random_attention_mask([self.batch_size, self.seq_length]				)

          __lowercase		:			Any	    =       None
          if self.use_token_type_ids:
              __lowercase		:			List[str]	    =       ids_tensor([self.batch_size, self.seq_length]				,       self.type_vocab_size				)

          __lowercase		:			Any	    =       None
          __lowercase		:			str	    =       None
          __lowercase		:			Optional[Any]	    =       None
          if self.use_labels:
              __lowercase		:			Optional[int]	    =       ids_tensor([self.batch_size]				,       self.type_sequence_label_size				)
              __lowercase		:			List[str]	    =       ids_tensor([self.batch_size, self.seq_length]				,       self.num_labels				)
              __lowercase		:			List[str]	    =       ids_tensor([self.batch_size]				,       self.num_choices				)

          __lowercase		:			str	    =       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 		snake_case_			(      self		:       List[str]				,       _snake_case		:       Optional[int]				,       _snake_case		:       List[Any]				,       _snake_case		:       Dict				,       _snake_case		:       Tuple				,       _snake_case		:       int				,       _snake_case		:       List[str]				,       _snake_case		:       List[Any]				,       _snake_case		:       Union[str, Any]				):
          __lowercase		:			Tuple	    =       TFLayoutLMModel(config=_snake_case				)

          __lowercase		:			Any	    =       model(_snake_case				,       _snake_case				,       attention_mask=_snake_case				,       token_type_ids=_snake_case				)
          __lowercase		:			Optional[int]	    =       model(_snake_case				,       _snake_case				,       token_type_ids=_snake_case				)
          __lowercase		:			List[Any]	    =       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 		snake_case_			(      self		:       Dict				,       _snake_case		:       List[str]				,       _snake_case		:       Optional[Any]				,       _snake_case		:       Dict				,       _snake_case		:       List[str]				,       _snake_case		:       Dict				,       _snake_case		:       List[Any]				,       _snake_case		:       str				,       _snake_case		:       Optional[int]				):
          __lowercase		:			List[Any]	    =       TFLayoutLMForMaskedLM(config=_snake_case				)

          __lowercase		:			Optional[Any]	    =       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 		snake_case_			(      self		:       Any				,       _snake_case		:       Tuple				,       _snake_case		:       List[str]				,       _snake_case		:       Any				,       _snake_case		:       Any				,       _snake_case		:       Union[str, Any]				,       _snake_case		:       Optional[Any]				,       _snake_case		:       int				,       _snake_case		:       str				):
          __lowercase		:			Optional[int]	    =       self.num_labels
          __lowercase		:			Dict	    =       TFLayoutLMForSequenceClassification(config=_snake_case				)

          __lowercase		:			Any	    =       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 		snake_case_			(      self		:       str				,       _snake_case		:       Tuple				,       _snake_case		:       Dict				,       _snake_case		:       Union[str, Any]				,       _snake_case		:       int				,       _snake_case		:       int				,       _snake_case		:       Dict				,       _snake_case		:       Optional[int]				,       _snake_case		:       Any				):
          __lowercase		:			Tuple	    =       self.num_labels
          __lowercase		:			Optional[int]	    =       TFLayoutLMForTokenClassification(config=_snake_case				)

          __lowercase		:			Union[str, Any]	    =       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 		snake_case_			(      self		:       Optional[int]				,       _snake_case		:       Optional[Any]				,       _snake_case		:       Any				,       _snake_case		:       List[Any]				,       _snake_case		:       Optional[Any]				,       _snake_case		:       Union[str, Any]				,       _snake_case		:       List[Any]				,       _snake_case		:       Any				,       _snake_case		:       List[str]				):
          __lowercase		:			int	    =       TFLayoutLMForQuestionAnswering(config=_snake_case				)

          __lowercase		:			Union[str, Any]	    =       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 		snake_case_			(      self		:       Optional[int]				):
          __lowercase		:			Tuple	    =       self.prepare_config_and_inputs()
          (
              __lowercase      
          )		:			Optional[Any]	    =       config_and_inputs
          __lowercase		:			int	    =       {
              '''input_ids''': input_ids,
              '''bbox''': bbox,
              '''token_type_ids''': token_type_ids,
              '''attention_mask''': input_mask,
          }
          return config, inputs_dict






@require_tf
class 						__lowerCAmelCase	(	lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase      ):



      """simple docstring"""







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




      def 		snake_case_			(      self		:       Optional[Any]				):
          __lowercase		:			Union[str, Any]	    =       TFLayoutLMModelTester(self				)
          __lowercase		:			Optional[int]	    =       ConfigTester(self				,       config_class=_snake_case				,       hidden_size=37				)




      def 		snake_case_			(      self		:       Tuple				):
          self.config_tester.run_common_tests()




      def 		snake_case_			(      self		:       Any				):
          __lowercase		:			Dict	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_snake_case				)




      def 		snake_case_			(      self		:       Union[str, Any]				):
          __lowercase		:			List[str]	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*_snake_case				)




      def 		snake_case_			(      self		:       Tuple				):
          __lowercase		:			Tuple	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*_snake_case				)




      def 		snake_case_			(      self		:       Union[str, Any]				):
          __lowercase		:			List[str]	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*_snake_case				)




      def 		snake_case_			(      self		:       Optional[Any]				):
          __lowercase		:			int	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*_snake_case				)




      @slow
      def 		snake_case_			(      self		:       List[Any]				):
          for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __lowercase		:			Tuple	    =       TFLayoutLMModel.from_pretrained(_snake_case				)
              self.assertIsNotNone(_snake_case				)




      @unittest.skip('''Onnx compliancy broke with TF 2.10'''				)
      def 		snake_case_			(      self		:       Dict				):
          pass






def     UpperCAmelCase_  (						) ->						str:
    # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
    # fmt: off
    __lowercase		:			Dict	    =       tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]	)  # noqa: E231
    __lowercase		:			Tuple	    =       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		:			Tuple	    =       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],[1_000,1_000,1_000,1_000]],[[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],[1_000,1_000,1_000,1_000]]]	)  # noqa: E231
    __lowercase		:			List[Any]	    =       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		:			Union[str, Any]	    =       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 						__lowerCAmelCase	(	unittest.TestCase      ):



      """simple docstring"""







      @slow
      def 		snake_case_			(      self		:       Union[str, Any]				):
          __lowercase		:			List[Any]	    =       TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''				)

          __lowercase		:			Optional[int]	    =       prepare_layoutlm_batch_inputs()

          # forward pass
          __lowercase		:			Tuple	    =       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		:			Optional[Any]	    =       tf.convert_to_tensor(
              [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]				,       )

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

          # test the pooled output on [1, :3]
          __lowercase		:			List[Any]	    =       tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52]				)

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




      @slow
      def 		snake_case_			(      self		:       Optional[int]				):
          # initialize model with randomly initialized sequence classification head
          __lowercase		:			Dict	    =       TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''				,       num_labels=2				)

          __lowercase		:			Union[str, Any]	    =       prepare_layoutlm_batch_inputs()

          # forward pass
          __lowercase		:			Union[str, Any]	    =       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		:			Dict	    =       outputs.loss
          __lowercase		:			int	    =       (2,)
          self.assertEqual(loss.shape				,       _snake_case				)

          # test the shape of the logits
          __lowercase		:			Optional[Any]	    =       outputs.logits
          __lowercase		:			int	    =       (2, 2)
          self.assertEqual(logits.shape				,       _snake_case				)




      @slow
      def 		snake_case_			(      self		:       Optional[Any]				):
          # initialize model with randomly initialized token classification head
          __lowercase		:			Union[str, Any]	    =       TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''				,       num_labels=13				)

          __lowercase		:			int	    =       prepare_layoutlm_batch_inputs()

          # forward pass
          __lowercase		:			Dict	    =       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		:			str	    =       outputs.logits
          __lowercase		:			Optional[Any]	    =       tf.convert_to_tensor((2, 25, 13)				)
          self.assertEqual(logits.shape				,       _snake_case				)




      @slow
      def 		snake_case_			(      self		:       Dict				):
          # initialize model with randomly initialized token classification head
          __lowercase		:			str	    =       TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''				)

          __lowercase		:			str	    =       prepare_layoutlm_batch_inputs()

          # forward pass
          __lowercase		:			Dict	    =       model(input_ids=_snake_case				,       bbox=_snake_case				,       attention_mask=_snake_case				,       token_type_ids=_snake_case				)

          # test the shape of the logits
          __lowercase		:			Optional[Any]	    =       tf.convert_to_tensor((2, 25)				)
          self.assertEqual(outputs.start_logits.shape				,       _snake_case				)
          self.assertEqual(outputs.end_logits.shape				,       _snake_case				)




from math import factorial

__lowerCAmelCase					:			Dict			      =		{str(d): factorial(d) for d in range(10)}


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						int:
    return sum(DIGIT_FACTORIAL[d] for d in str(__lowerCAmelCase	)	)


def     UpperCAmelCase_  (						) ->						int:
    __lowercase		:			int	    =       7 * factorial(9	) + 1
    return sum(i for i in range(3	,					__lowerCAmelCase	) if sum_of_digit_factorial(__lowerCAmelCase	) == i	)


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


