



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



 def __init__(     self						,		lowercase						,		lowercase=1_3						,		lowercase=7						,		lowercase=True						,		lowercase=True						,		lowercase=True						,		lowercase=True						,		lowercase=9_9						,		lowercase=3_2						,		lowercase=2						,		lowercase=4						,		lowercase=3_7						,		lowercase="gelu"						,		lowercase=0.1						,		lowercase=0.1						,		lowercase=5_1_2						,		lowercase=1_6						,		lowercase=2						,		lowercase=0.02						,		lowercase=3						,		lowercase=4						,		lowercase=None						,		lowercase=1_0_0_0						,		)     ->							Any:
  __UpperCamelCase 					=     parent
  __UpperCamelCase 					=     batch_size
  __UpperCamelCase 					=     seq_length
  __UpperCamelCase 					=     is_training
  __UpperCamelCase 					=     use_input_mask
  __UpperCamelCase 					=     use_token_type_ids
  __UpperCamelCase 					=     use_labels
  __UpperCamelCase 					=     vocab_size
  __UpperCamelCase 					=     hidden_size
  __UpperCamelCase 					=     num_hidden_layers
  __UpperCamelCase 					=     num_attention_heads
  __UpperCamelCase 					=     intermediate_size
  __UpperCamelCase 					=     hidden_act
  __UpperCamelCase 					=     hidden_dropout_prob
  __UpperCamelCase 					=     attention_probs_dropout_prob
  __UpperCamelCase 					=     max_position_embeddings
  __UpperCamelCase 					=     type_vocab_size
  __UpperCamelCase 					=     type_sequence_label_size
  __UpperCamelCase 					=     initializer_range
  __UpperCamelCase 					=     num_labels
  __UpperCamelCase 					=     num_choices
  __UpperCamelCase 					=     scope
  __UpperCamelCase 					=     range_bbox



 def       __lowerCamelCase (     self	)     ->							Union[str, Any]:
  __UpperCamelCase 					=     ids_tensor([self.batch_size, self.seq_length]						,		self.vocab_size	)

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

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

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

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

  __UpperCamelCase 					=     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       __lowerCamelCase (     self						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase	)     ->							Union[str, Any]:
  __UpperCamelCase 					=     TFLayoutLMModel(config=lowercase	)

  __UpperCamelCase 					=     model(lowercase						,		lowercase						,		attention_mask=lowercase						,		token_type_ids=lowercase	)
  __UpperCamelCase 					=     model(lowercase						,		lowercase						,		token_type_ids=lowercase	)
  __UpperCamelCase 					=     model(lowercase						,		lowercase	)
  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       __lowerCamelCase (     self						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase	)     ->							Optional[int]:
  __UpperCamelCase 					=     TFLayoutLMForMaskedLM(config=lowercase	)

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



 def       __lowerCamelCase (     self						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase	)     ->							int:
  __UpperCamelCase 					=     self.num_labels
  __UpperCamelCase 					=     TFLayoutLMForSequenceClassification(config=lowercase	)

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



 def       __lowerCamelCase (     self						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase	)     ->							Union[str, Any]:
  __UpperCamelCase 					=     self.num_labels
  __UpperCamelCase 					=     TFLayoutLMForTokenClassification(config=lowercase	)

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



 def       __lowerCamelCase (     self						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase						,		lowercase	)     ->							Tuple:
  __UpperCamelCase 					=     TFLayoutLMForQuestionAnswering(config=lowercase	)

  __UpperCamelCase 					=     model(lowercase						,		lowercase						,		attention_mask=lowercase						,		token_type_ids=lowercase	)
  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       __lowerCamelCase (     self	)     ->							Any:
  __UpperCamelCase 					=     self.prepare_config_and_inputs()
  (
      __UpperCamelCase    
  ) 					=     config_and_inputs
  __UpperCamelCase 					=     {
      '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):
 __SCREAMING_SNAKE_CASE    					= (
     (
         TFLayoutLMModel,
         TFLayoutLMForMaskedLM,
         TFLayoutLMForTokenClassification,
         TFLayoutLMForSequenceClassification,
         TFLayoutLMForQuestionAnswering,
     )
     if is_tf_available()
     else ()
 )
 __SCREAMING_SNAKE_CASE    					= (
     {
         '''feature-extraction''': TFLayoutLMModel,
         '''fill-mask''': TFLayoutLMForMaskedLM,
         '''text-classification''': TFLayoutLMForSequenceClassification,
         '''token-classification''': TFLayoutLMForTokenClassification,
         '''zero-shot''': TFLayoutLMForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 __SCREAMING_SNAKE_CASE    					= False
 __SCREAMING_SNAKE_CASE    					= True
 __SCREAMING_SNAKE_CASE    					= 1_0



 def       __lowerCamelCase (     self	)     ->							str:
  __UpperCamelCase 					=     TFLayoutLMModelTester(self	)
  __UpperCamelCase 					=     ConfigTester(self						,		config_class=lowercase						,		hidden_size=3_7	)



 def       __lowerCamelCase (     self	)     ->							Union[str, Any]:
  self.config_tester.run_common_tests()



 def       __lowerCamelCase (     self	)     ->							Any:
  __UpperCamelCase 					=     self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*lowercase	)



 def       __lowerCamelCase (     self	)     ->							int:
  __UpperCamelCase 					=     self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_masked_lm(*lowercase	)



 def       __lowerCamelCase (     self	)     ->							Any:
  __UpperCamelCase 					=     self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_sequence_classification(*lowercase	)



 def       __lowerCamelCase (     self	)     ->							str:
  __UpperCamelCase 					=     self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_token_classification(*lowercase	)



 def       __lowerCamelCase (     self	)     ->							Any:
  __UpperCamelCase 					=     self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_question_answering(*lowercase	)



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





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




 @unittest.skip("""Onnx compliancy broke with TF 2.10"""	)
 def       __lowerCamelCase (     self	)     ->							Optional[int]:
  pass







def _lowercase      (     ):



 '''simple docstring'''



 __UpperCamelCase 					=     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
 __UpperCamelCase 					=     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
 __UpperCamelCase 					=     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
 __UpperCamelCase 					=     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)
 __UpperCamelCase 					=     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):



 @slow
 def       __lowerCamelCase (     self	)     ->							List[str]:
  __UpperCamelCase 					=     TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""	)

  __UpperCamelCase 					=     prepare_layoutlm_batch_inputs()

  # forward pass
  __UpperCamelCase 					=     model(input_ids=lowercase						,		bbox=lowercase						,		attention_mask=lowercase						,		token_type_ids=lowercase	)

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

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

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



 @slow
 def       __lowerCamelCase (     self	)     ->							List[str]:
  __UpperCamelCase 					=     TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""						,		num_labels=2	)

  __UpperCamelCase 					=     prepare_layoutlm_batch_inputs()

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

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

  # test the shape of the logits
  __UpperCamelCase 					=     outputs.logits
  __UpperCamelCase 					=     (2, 2)
  self.assertEqual(logits.shape						,		lowercase	)



 @slow
 def       __lowerCamelCase (     self	)     ->							List[Any]:
  __UpperCamelCase 					=     TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""						,		num_labels=1_3	)

  __UpperCamelCase 					=     prepare_layoutlm_batch_inputs()

  # forward pass
  __UpperCamelCase 					=     model(
      input_ids=lowercase						,		bbox=lowercase						,		attention_mask=lowercase						,		token_type_ids=lowercase						,		labels=lowercase	)

  # test the shape of the logits
  __UpperCamelCase 					=     outputs.logits
  __UpperCamelCase 					=     tf.convert_to_tensor((2, 2_5, 1_3)	)
  self.assertEqual(logits.shape						,		lowercase	)




 @slow
 def       __lowerCamelCase (     self	)     ->							Dict:
  __UpperCamelCase 					=     TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""	)

  __UpperCamelCase 					=     prepare_layoutlm_batch_inputs()

  # forward pass
  __UpperCamelCase 					=     model(input_ids=lowercase						,		bbox=lowercase						,		attention_mask=lowercase						,		token_type_ids=lowercase	)

  # test the shape of the logits
  __UpperCamelCase 					=     tf.convert_to_tensor((2, 2_5)	)
  self.assertEqual(outputs.start_logits.shape						,		lowercase	)
  self.assertEqual(outputs.end_logits.shape						,		lowercase	)






"""simple docstring"""
def 						__a   (	_SCREAMING_SNAKE_CASE		,     _SCREAMING_SNAKE_CASE = False   )	->str:

  if not isinstance(_SCREAMING_SNAKE_CASE		,     _SCREAMING_SNAKE_CASE   ):
    a__:     Optional[int]										=	F'Expected string as input, found {type(_SCREAMING_SNAKE_CASE   )}'
    raise ValueError(_SCREAMING_SNAKE_CASE   )
  if not isinstance(_SCREAMING_SNAKE_CASE		,     _SCREAMING_SNAKE_CASE   ):
    a__:     List[str]										=	F'Expected boolean as use_pascal parameter, found {type(_SCREAMING_SNAKE_CASE   )}'
    raise ValueError(_SCREAMING_SNAKE_CASE   )

  a__:     int										=	input_str.split('_'   )

  a__:     List[str]										=	0 if use_pascal else 1

  a__:     List[str]										=	words[start_index:]

  a__:     List[str]										=	[word[0].upper() + word[1:] for word in words_to_capitalize]

  a__:     List[str]										=	'' if use_pascal else words[0]

  return "".join([initial_word, *capitalized_words]   )


if __name__ == "__main__":
 from doctest import testmod

 testmod()


