





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




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







					"""simple docstring"""






					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    a_       (			self   :    List[Any]   )	->	int:







					"""simple docstring"""






					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(lowerCAmelCase__   )

					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    a_       (			self   :    Optional[Any]							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    Optional[int]							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    List[Any]							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    str							,	__lowerCAmelCase   :    Dict							,	__lowerCAmelCase   :    List[str]   )	->	List[str]:







					"""simple docstring"""






					A__        =   TFLayoutLMModel(config=lowerCAmelCase__   )

					A__        =   model(lowerCAmelCase__							,	lowerCAmelCase__							,	attention_mask=lowerCAmelCase__							,	token_type_ids=lowerCAmelCase__   )
					A__        =   model(lowerCAmelCase__							,	lowerCAmelCase__							,	token_type_ids=lowerCAmelCase__   )
					A__        =   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    a_       (			self   :    int							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    Optional[int]							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    List[Any]							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    Dict							,	__lowerCAmelCase   :    Optional[Any]   )	->	Any:







					"""simple docstring"""






					A__        =   TFLayoutLMForMaskedLM(config=lowerCAmelCase__   )

					A__        =   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    a_       (			self   :    Dict							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    Any							,	__lowerCAmelCase   :    List[Any]							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    str							,	__lowerCAmelCase   :    str   )	->	str:







					"""simple docstring"""






					A__        =   self.num_labels
					A__        =   TFLayoutLMForSequenceClassification(config=lowerCAmelCase__   )

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






			def    a_       (			self   :    List[Any]							,	__lowerCAmelCase   :    Optional[int]							,	__lowerCAmelCase   :    Any							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    List[Any]   )	->	Optional[Any]:







					"""simple docstring"""






					A__        =   self.num_labels
					A__        =   TFLayoutLMForTokenClassification(config=lowerCAmelCase__   )

					A__        =   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    a_       (			self   :    Optional[int]							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    Dict							,	__lowerCAmelCase   :    List[str]							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    Dict							,	__lowerCAmelCase   :    Optional[int]   )	->	Any:







					"""simple docstring"""






					A__        =   TFLayoutLMForQuestionAnswering(config=lowerCAmelCase__   )

					A__        =   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    a_       (			self   :    List[Any]   )	->	str:







					"""simple docstring"""






					A__        =   self.prepare_config_and_inputs()
					(
					    (
					    A__
					)      ,			(
					    A__
					)      ,			(
					    A__
					)      ,			(
					    A__
					)      ,			(
					    A__
					)      ,			(
					    A__
					)      ,			(
					    A__
					)      ,			(
					    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   A			(__a   ,     __a   ,     unittest.TestCase    ):
			'''simple docstring'''




			__lowerCamelCase	:       int							=    (
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			__lowerCamelCase	:       str							=    (
			    {
			        '''feature-extraction''': TFLayoutLMModel,
			        '''fill-mask''': TFLayoutLMForMaskedLM,
			        '''text-classification''': TFLayoutLMForSequenceClassification,
			        '''token-classification''': TFLayoutLMForTokenClassification,
			        '''zero-shot''': TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__lowerCamelCase	:       Tuple							=    False
			__lowerCamelCase	:       int							=    True
			__lowerCamelCase	:       Any							=    10






			def    a_       (			self   :    Optional[int]   )	->	Optional[Any]:







					"""simple docstring"""






					A__        =   TFLayoutLMModelTester(self   )
					A__        =   ConfigTester(self							,	config_class=lowerCAmelCase__							,	hidden_size=37   )






			def    a_       (			self   :    Optional[int]   )	->	Union[str, Any]:







					"""simple docstring"""






					self.config_tester.run_common_tests()






			def    a_       (			self   :    List[Any]   )	->	int:







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowerCAmelCase__   )






			def    a_       (			self   :    Optional[int]   )	->	Union[str, Any]:







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__   )






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







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__   )






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







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__   )






			def    a_       (			self   :    Any   )	->	Optional[Any]:







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__   )






			@slow
			def    a_       (			self   :    Dict   )	->	Dict:







					"""simple docstring"""






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







			@unittest.skip("""Onnx compliancy broke with TF 2.10"""   )
			def    a_       (			self   :    List[str]   )	->	int:







					"""simple docstring"""






					pass







def    __lowerCamelCase					(							)		->				Tuple:






		"""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   A			(unittest.TestCase    ):
			'''simple docstring'''




			@slow
			def    a_       (			self   :    str   )	->	Optional[int]:







					"""simple docstring"""






					A__        =   TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""   )

					A__      ,			A__      ,			A__      ,			A__      ,			A__        =   prepare_layoutlm_batch_inputs()

					# forward pass
					A__        =   model(input_ids=lowerCAmelCase__							,	bbox=lowerCAmelCase__							,	attention_mask=lowerCAmelCase__							,	token_type_ids=lowerCAmelCase__   )

					# 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]							,	lowerCAmelCase__							,	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]							,	lowerCAmelCase__							,	atol=1e-3   )   )






			@slow
			def    a_       (			self   :    Union[str, Any]   )	->	Tuple:







					"""simple docstring"""






					A__        =   TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,	num_labels=2   )

					A__      ,			A__      ,			A__      ,			A__      ,			A__        =   prepare_layoutlm_batch_inputs()

					# forward pass
					A__        =   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
					A__        =   outputs.loss
					A__        =   (2,)
					self.assertEqual(loss.shape							,	lowerCAmelCase__   )

					# test the shape of the logits
					A__        =   outputs.logits
					A__        =   (2, 2)
					self.assertEqual(logits.shape							,	lowerCAmelCase__   )






			@slow
			def    a_       (			self   :    List[Any]   )	->	List[Any]:







					"""simple docstring"""






					A__        =   TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,	num_labels=13   )

					A__      ,			A__      ,			A__      ,			A__      ,			A__        =   prepare_layoutlm_batch_inputs()

					# forward pass
					A__        =   model(
					    input_ids=lowerCAmelCase__							,	bbox=lowerCAmelCase__							,	attention_mask=lowerCAmelCase__							,	token_type_ids=lowerCAmelCase__							,	labels=lowerCAmelCase__   )

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







			@slow
			def    a_       (			self   :    str   )	->	List[str]:







					"""simple docstring"""






					A__        =   TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""   )

					A__      ,			A__      ,			A__      ,			A__      ,			A__        =   prepare_layoutlm_batch_inputs()

					# forward pass
					A__        =   model(input_ids=lowerCAmelCase__							,	bbox=lowerCAmelCase__							,	attention_mask=lowerCAmelCase__							,	token_type_ids=lowerCAmelCase__   )

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





"""simple docstring"""





def 						_lowerCAmelCase				(				UpperCamelCase_ = 10**9				):
		__SCREAMING_SNAKE_CASE            = 1
		__SCREAMING_SNAKE_CASE            = 2

		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = 0
		while perimeter <= max_perimeter:
				perimeters_sum += perimeter

				prev_value += 2 * value
				value += prev_value

				__SCREAMING_SNAKE_CASE            = 2 * value + 2 if i % 2 == 0 else 2 * value - 2
				i += 1

		return perimeters_sum


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




