






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

	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.02		,    __UpperCAmelCase=3		,    __UpperCAmelCase=4		,    __UpperCAmelCase=None		,    __UpperCAmelCase=1000		,    )->					List[str]:







							'''simple docstring'''





							lowerCAmelCase__       =						parent
							lowerCAmelCase__       =						batch_size
							lowerCAmelCase__       =						seq_length
							lowerCAmelCase__       =						is_training
							lowerCAmelCase__       =						use_input_mask
							lowerCAmelCase__       =						use_token_type_ids
							lowerCAmelCase__       =						use_labels
							lowerCAmelCase__       =						vocab_size
							lowerCAmelCase__       =						hidden_size
							lowerCAmelCase__       =						num_hidden_layers
							lowerCAmelCase__       =						num_attention_heads
							lowerCAmelCase__       =						intermediate_size
							lowerCAmelCase__       =						hidden_act
							lowerCAmelCase__       =						hidden_dropout_prob
							lowerCAmelCase__       =						attention_probs_dropout_prob
							lowerCAmelCase__       =						max_position_embeddings
							lowerCAmelCase__       =						type_vocab_size
							lowerCAmelCase__       =						type_sequence_label_size
							lowerCAmelCase__       =						initializer_range
							lowerCAmelCase__       =						num_labels
							lowerCAmelCase__       =						num_choices
							lowerCAmelCase__       =						scope
							lowerCAmelCase__       =						range_bbox

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







							'''simple docstring'''





							lowerCAmelCase__       =						ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size       )

							# convert bbox to numpy since TF does not support item assignment
							lowerCAmelCase__       =						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]:
																									lowerCAmelCase__       =						bbox[i, j, 3]
																									lowerCAmelCase__       =						bbox[i, j, 1]
																									lowerCAmelCase__       =						t
																			if bbox[i, j, 2] < bbox[i, j, 0]:
																									lowerCAmelCase__       =						bbox[i, j, 2]
																									lowerCAmelCase__       =						bbox[i, j, 0]
																									lowerCAmelCase__       =						t
							lowerCAmelCase__       =						tf.convert_to_tensor(__UpperCAmelCase       )

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

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

							lowerCAmelCase__       =						None
							lowerCAmelCase__       =						None
							lowerCAmelCase__       =						None
							if self.use_labels:
													lowerCAmelCase__       =						ids_tensor([self.batch_size]		,    self.type_sequence_label_size       )
													lowerCAmelCase__       =						ids_tensor([self.batch_size, self.seq_length]		,    self.num_labels       )
													lowerCAmelCase__       =						ids_tensor([self.batch_size]		,    self.num_choices       )

							lowerCAmelCase__       =						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		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					List[str]:







							'''simple docstring'''





							lowerCAmelCase__       =						TFLayoutLMModel(config=__UpperCAmelCase       )

							lowerCAmelCase__       =						model(__UpperCAmelCase		,    __UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase       )
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    __UpperCAmelCase		,    token_type_ids=__UpperCAmelCase       )
							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					str:







							'''simple docstring'''





							lowerCAmelCase__       =						TFLayoutLMForMaskedLM(config=__UpperCAmelCase       )

							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Union[str, Any]:







							'''simple docstring'''





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

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

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Optional[Any]:







							'''simple docstring'''





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

							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						TFLayoutLMForQuestionAnswering(config=__UpperCAmelCase       )

							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						self.prepare_config_and_inputs()
							(
							    (
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							
							)       =						config_and_inputs
							lowerCAmelCase__       =						{
							    "input_ids": input_ids,
							    "bbox": bbox,
							    "token_type_ids": token_type_ids,
							    "attention_mask": input_mask,
							}
							return config, inputs_dict





@require_tf
class      lowercase__     (			_UpperCAmelCase,					_UpperCAmelCase,					unittest.TestCase	):
	a_         =(
	    (
	        TFLayoutLMModel,
	        TFLayoutLMForMaskedLM,
	        TFLayoutLMForTokenClassification,
	        TFLayoutLMForSequenceClassification,
	        TFLayoutLMForQuestionAnswering,
	    )
	    if is_tf_available()
	    else ()
	)
	a_         =(
	    {
	        """feature-extraction""": TFLayoutLMModel,
	        """fill-mask""": TFLayoutLMForMaskedLM,
	        """text-classification""": TFLayoutLMForSequenceClassification,
	        """token-classification""": TFLayoutLMForTokenClassification,
	        """zero-shot""": TFLayoutLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	a_         =False
	a_         =True
	a_         =10

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





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

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







							'''simple docstring'''





							self.config_tester.run_common_tests()

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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


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







							'''simple docstring'''





							pass





def        _a  (     ) ->   Any:
						"""simple docstring"""







						lowerCAmelCase__       =						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
						lowerCAmelCase__       =						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
						lowerCAmelCase__       =						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
						lowerCAmelCase__       =						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)
						lowerCAmelCase__       =						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      lowercase__     (			unittest.TestCase	):

	@slow
	def 		UpperCAmelCase  (							self       )->					str:







							'''simple docstring'''





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

							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__       =						prepare_layoutlm_batch_inputs()

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

							# test the sequence output on [0, :3, :3]
							lowerCAmelCase__       =						tf.convert_to_tensor(
							    [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]		,    )

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

							# test the pooled output on [1, :3]
							lowerCAmelCase__       =						tf.convert_to_tensor([-0.6_580, -0.0_214, 0.8_552]       )

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

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







							'''simple docstring'''





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

							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__       =						prepare_layoutlm_batch_inputs()

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

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

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







							'''simple docstring'''





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

							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__       =						prepare_layoutlm_batch_inputs()

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

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


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







							'''simple docstring'''





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

							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__      ,							lowerCAmelCase__       =						prepare_layoutlm_batch_inputs()

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

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














from collections import defaultdict
from math import ceil, sqrt


def        _a  (     UpperCamelCase_					:				int = 1_000_000    ,   UpperCamelCase_					:				int = 10   ) ->   int:
						"""simple docstring"""







						lowerCAmelCase__       =						defaultdict(UpperCamelCase_   )

						for outer_width in range(3    ,   (t_limit // 4) + 2   ):
												if outer_width * outer_width > t_limit:
																		lowerCAmelCase__       =						max(
																		    ceil(sqrt(outer_width * outer_width - t_limit   )   )    ,   1   )
												else:
																		lowerCAmelCase__       =						1

												hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

												for hole_width in range(UpperCamelCase_    ,   outer_width - 1    ,   2   ):
																		count[outer_width * outer_width - hole_width * hole_width] += 1

						return sum(1 for n in count.values() if 1 <= n <= 10   )


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






