



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

   '''simple docstring'''




   def __init__(    self	:      List[Any]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Optional[int]=13      ,					lowerCAmelCase	:      List[str]=7      ,					lowerCAmelCase	:      List[Any]=True      ,					lowerCAmelCase	:      Union[str, Any]=True      ,					lowerCAmelCase	:      Any=True      ,					lowerCAmelCase	:      Tuple=True      ,					lowerCAmelCase	:      int=99      ,					lowerCAmelCase	:      Optional[int]=32      ,					lowerCAmelCase	:      Optional[Any]=2      ,					lowerCAmelCase	:      Optional[Any]=4      ,					lowerCAmelCase	:      Optional[int]=37      ,					lowerCAmelCase	:      Any="gelu"      ,					lowerCAmelCase	:      List[Any]=0.1      ,					lowerCAmelCase	:      Dict=0.1      ,					lowerCAmelCase	:      int=5_12      ,					lowerCAmelCase	:      str=16      ,					lowerCAmelCase	:      Tuple=2      ,					lowerCAmelCase	:      str=0.02      ,					lowerCAmelCase	:      Optional[int]=3      ,					lowerCAmelCase	:      Any=4      ,					lowerCAmelCase	:      Union[str, Any]=None      ,					lowerCAmelCase	:      Any=10_00      ,					)						->					Optional[Any]:




         """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	:      Dict)						->					str:




         """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(lowerCAmelCase)

         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	:      Optional[Any]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Dict)						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	TFLayoutLMModel(config=lowerCAmelCase)

         lowercase__  =	model(lowerCAmelCase      ,					lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase)
         lowercase__  =	model(lowerCAmelCase      ,					lowerCAmelCase      ,					token_type_ids=lowerCAmelCase)
         lowercase__  =	model(lowerCAmelCase      ,					lowerCAmelCase)
         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	:      Dict      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      List[str])						->					Tuple:




         """simple docstring"""

         lowercase__  =	TFLayoutLMForMaskedLM(config=lowerCAmelCase)

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


   def       UpperCAmelCase		(    self	:      Optional[int]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      int)						->					str:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMForSequenceClassification(config=lowerCAmelCase)

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


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Tuple)						->					Tuple:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMForTokenClassification(config=lowerCAmelCase)

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


   def       UpperCAmelCase		(    self	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      Optional[Any])						->					int:




         """simple docstring"""

         lowercase__  =	TFLayoutLMForQuestionAnswering(config=lowerCAmelCase)

         lowercase__  =	model(lowerCAmelCase      ,					lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=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       UpperCAmelCase		(    self	:      Dict)						->					Optional[int]:




         """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    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	Optional[Any]												=     (
       (
           TFLayoutLMModel,
           TFLayoutLMForMaskedLM,
           TFLayoutLMForTokenClassification,
           TFLayoutLMForSequenceClassification,
           TFLayoutLMForQuestionAnswering,
       )
       if is_tf_available()
       else ()
   )
   A     :	Any												=     (
       {
           "feature-extraction": TFLayoutLMModel,
           "fill-mask": TFLayoutLMForMaskedLM,
           "text-classification": TFLayoutLMForSequenceClassification,
           "token-classification": TFLayoutLMForTokenClassification,
           "zero-shot": TFLayoutLMForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   A     :	Optional[int]												=     False
   A     :	str												=     True
   A     :	Optional[int]												=     10


   def       UpperCAmelCase		(    self	:      Dict)						->					Any:




         """simple docstring"""

         lowercase__  =	TFLayoutLMModelTester(self)
         lowercase__  =	ConfigTester(self      ,					config_class=lowerCAmelCase      ,					hidden_size=37)


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




         """simple docstring"""

         self.config_tester.run_common_tests()


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




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      Tuple)						->					Optional[int]:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      List[str])						->					Any:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      Tuple)						->					Any:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      Tuple)						->					Any:




         """simple docstring"""

         lowercase__  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase)


   @slow
   def       UpperCAmelCase		(    self	:      int)						->					Optional[Any]:




         """simple docstring"""

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



   @unittest.skip('Onnx compliancy broke with TF 2.10')
   def       UpperCAmelCase		(    self	:      Tuple)						->					List[Any]:




         """simple docstring"""

         pass

def 	_lowerCAmelCase (    ):
      # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
      # fmt: off
      lowercase__  =	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__  =	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],[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__  =	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    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   @slow
   def       UpperCAmelCase		(    self	:      Any)						->					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=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase)

         # test the sequence output on [0, :3, :3]
         lowercase__  =	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]      ,					lowerCAmelCase      ,					atol=1E-3))

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

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


   @slow
   def       UpperCAmelCase		(    self	:      Optional[int])						->					Any:




         """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=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					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      ,					lowerCAmelCase)

         # test the shape of the logits
         lowercase__  =	outputs.logits
         lowercase__  =	(2, 2)
         self.assertEqual(logits.shape      ,					lowerCAmelCase)


   @slow
   def       UpperCAmelCase		(    self	:      str)						->					int:




         """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=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					labels=lowerCAmelCase)

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



   @slow
   def       UpperCAmelCase		(    self	:      Any)						->					Optional[int]:




         """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=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase)

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





def 	_lowerCAmelCase (    A__ = 600_851_475_143						):

      try:
            lowercase__  =	int(A__						)
      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.'						)
      lowercase__  =	2
      lowercase__  =	0
      if n == 2:
            return 2
      while n > 2:
            while n % i != 0:
                  i += 1
            lowercase__  =	i
            while n % i == 0:
                  lowercase__  =	n // i
            i += 1
      return int(A__						)


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