






'''simple docstring'''
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  _snake_case :

					"""simple docstring"""





					def __init__(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__=13 ,			UpperCAmelCase__=7 ,			UpperCAmelCase__=True ,			UpperCAmelCase__=True ,			UpperCAmelCase__=True ,			UpperCAmelCase__=True ,			UpperCAmelCase__=99 ,			UpperCAmelCase__=32 ,			UpperCAmelCase__=2 ,			UpperCAmelCase__=4 ,			UpperCAmelCase__=37 ,			UpperCAmelCase__="gelu" ,			UpperCAmelCase__=0.1 ,			UpperCAmelCase__=0.1 ,			UpperCAmelCase__=512 ,			UpperCAmelCase__=16 ,			UpperCAmelCase__=2 ,			UpperCAmelCase__=0.0_2 ,			UpperCAmelCase__=3 ,			UpperCAmelCase__=4 ,			UpperCAmelCase__=None ,			UpperCAmelCase__=1000 ,			)   ->						Optional[Any]:
										a_						= parent
										a_						= batch_size
										a_						= 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_						= num_labels
										a_						= num_choices
										a_						= scope
										a_						= range_bbox




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						List[Any]:
										a_						= ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size  )

										# convert bbox to numpy since TF does not support item assignment
										a_						= 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]:
																									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_						= tf.convert_to_tensor(UpperCAmelCase__  )

										a_						= None
										if self.use_input_mask:
															a_						= random_attention_mask([self.batch_size, self.seq_length]  )

										a_						= None
										if self.use_token_type_ids:
															a_						= ids_tensor([self.batch_size, self.seq_length] ,			self.type_vocab_size  )

										a_						= None
										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.seq_length] ,			self.num_labels  )
															a_						= ids_tensor([self.batch_size] ,			self.num_choices  )

										a_						= 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 			__SCREAMING_SNAKE_CASE			(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__  )   ->						Dict:
										a_						= TFLayoutLMModel(config=UpperCAmelCase__  )

										a_						= model(UpperCAmelCase__ ,			UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__  )
										a_						= model(UpperCAmelCase__ ,			UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__  )
										a_						= model(UpperCAmelCase__ ,			UpperCAmelCase__  )
										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 			__SCREAMING_SNAKE_CASE			(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__  )   ->						List[Any]:
										a_						= TFLayoutLMForMaskedLM(config=UpperCAmelCase__  )

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




					def 			__SCREAMING_SNAKE_CASE			(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__  )   ->						Any:
										a_						= self.num_labels
										a_						= TFLayoutLMForSequenceClassification(config=UpperCAmelCase__  )

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




					def 			__SCREAMING_SNAKE_CASE			(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__  )   ->						Optional[Any]:
										a_						= self.num_labels
										a_						= TFLayoutLMForTokenClassification(config=UpperCAmelCase__  )

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




					def 			__SCREAMING_SNAKE_CASE			(  self ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__ ,			UpperCAmelCase__  )   ->						str:
										a_						= TFLayoutLMForQuestionAnswering(config=UpperCAmelCase__  )

										a_						= model(UpperCAmelCase__ ,			UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=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  )   ->						Tuple:
										a_						= self.prepare_config_and_inputs()
										(
										    a_			
										)						= config_and_inputs
										a_						= {
										    'input_ids': input_ids,
										    'bbox': bbox,
										    'token_type_ids': token_type_ids,
										    'attention_mask': input_mask,
										}
										return config, inputs_dict



@require_tf
class  _snake_case (					snake_case  ,       snake_case  ,       unittest.TestCase       ):

					"""simple docstring"""





					_UpperCamelCase					=   (
					    (
					        TFLayoutLMModel,
					        TFLayoutLMForMaskedLM,
					        TFLayoutLMForTokenClassification,
					        TFLayoutLMForSequenceClassification,
					        TFLayoutLMForQuestionAnswering,
					    )
					    if is_tf_available()
					    else ()
					)
					_UpperCamelCase					=   (
					    {
					        "feature-extraction": TFLayoutLMModel,
					        "fill-mask": TFLayoutLMForMaskedLM,
					        "text-classification": TFLayoutLMForSequenceClassification,
					        "token-classification": TFLayoutLMForTokenClassification,
					        "zero-shot": TFLayoutLMForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					_UpperCamelCase					=   False
					_UpperCamelCase					=   True
					_UpperCamelCase					=   10




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Tuple:
										a_						= TFLayoutLMModelTester(self  )
										a_						= ConfigTester(self ,			config_class=UpperCAmelCase__ ,			hidden_size=37  )




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Optional[int]:
										self.config_tester.run_common_tests()




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Dict:
										a_						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__  )




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Tuple:
										a_						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase__  )




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Dict:
										a_						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__  )




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Optional[Any]:
										a_						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__  )




					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						str:
										a_						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__  )




					@slow
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Tuple:
										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															a_						= TFLayoutLMModel.from_pretrained(UpperCAmelCase__  )
															self.assertIsNotNone(UpperCAmelCase__  )




					@unittest.skip('Onnx compliancy broke with TF 2.10'  )
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						int:
										pass



def 				a						( )					->					List[str]:






					"""simple docstring"""







					a_						= tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]			)  # noqa: E231
					a_						= 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
					a_						= tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]			)  # noqa: E231
					a_						= 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)
					a_						= tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]			)  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels





@require_tf
class  _snake_case (					unittest.TestCase       ):

					"""simple docstring"""





					@slow
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Optional[int]:
										a_						= TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'  )

										a_						= prepare_layoutlm_batch_inputs()

										# forward pass
										a_						= model(input_ids=UpperCAmelCase__ ,			bbox=UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__  )

										# test the sequence output on [0, :3, :3]
										a_						= tf.convert_to_tensor(
										    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]] ,			)

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

										# test the pooled output on [1, :3]
										a_						= tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]  )

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




					@slow
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Dict:
										a_						= TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased' ,			num_labels=2  )

										a_						= prepare_layoutlm_batch_inputs()

										# forward pass
										a_						= model(
										    input_ids=UpperCAmelCase__ ,			bbox=UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__ ,			labels=tf.convert_to_tensor([1, 1]  ) ,			)

										# test whether we get a loss as a scalar
										a_						= outputs.loss
										a_						= (2,)
										self.assertEqual(loss.shape ,			UpperCAmelCase__  )

										# test the shape of the logits
										a_						= outputs.logits
										a_						= (2, 2)
										self.assertEqual(logits.shape ,			UpperCAmelCase__  )




					@slow
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						int:
										a_						= TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased' ,			num_labels=13  )

										a_						= prepare_layoutlm_batch_inputs()

										# forward pass
										a_						= model(
										    input_ids=UpperCAmelCase__ ,			bbox=UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__ ,			labels=UpperCAmelCase__  )

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




					@slow
					def 			__SCREAMING_SNAKE_CASE			(  self  )   ->						Optional[int]:
										a_						= TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'  )

										a_						= prepare_layoutlm_batch_inputs()

										# forward pass
										a_						= model(input_ids=UpperCAmelCase__ ,			bbox=UpperCAmelCase__ ,			attention_mask=UpperCAmelCase__ ,			token_type_ids=UpperCAmelCase__  )

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





'''simple docstring'''






import warnings
from functools import wraps
from typing import Callable





def lowerCamelCase__     (		__lowerCamelCase			:				Callable				):







   '''simple docstring'''




   @wraps(__lowerCamelCase				)
   def _inner_fn(*__lowerCamelCase			:				int			,       **__lowerCamelCase			:				Optional[Any]				):
      warnings.warn(
          (f"'{fn.__name__}' is experimental and might be subject to breaking changes in the future.")			,       __lowerCamelCase			,       )
      return fn(*__lowerCamelCase			,       **__lowerCamelCase				)

   return _inner_fn

