


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






     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=1_000     ,							)       ->    Dict:
          _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		)       ->    Union[str, 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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    str:
          _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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    Optional[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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    List[str]:
          _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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    List[str]:
          _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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    int:
          _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  a_					(			self		)       ->    Any:
          _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 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ,			lowerCamelCase__ ,			unittest.TestCase ):
     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  a_					(			self		)       ->    Tuple:
          _a						=		TFLayoutLMModelTester(self		)
          _a						=		ConfigTester(self     ,							config_class=UpperCAmelCase__     ,							hidden_size=37		)






     def  a_					(			self		)       ->    List[Any]:
          self.config_tester.run_common_tests()






     def  a_					(			self		)       ->    List[str]:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*UpperCAmelCase__		)






     def  a_					(			self		)       ->    List[Any]:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase__		)






     def  a_					(			self		)       ->    List[Any]:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__		)






     def  a_					(			self		)       ->    List[str]:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__		)






     def  a_					(			self		)       ->    Any:
          _a						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__		)






     @slow
     def  a_					(			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  a_					(			self		)       ->    Optional[int]:
          pass







def __UpperCamelCase   (			)      ->     List[Any]:







     '''simple docstring'''






     _a						=		tf.convert_to_tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]]				)  # 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],[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],[1000,1000,1000,1000]],[[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],[1000,1000,1000,1000]]]				)  # 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([[-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 						__SCREAMING_SNAKE_CASE					(      unittest.TestCase ):






     @slow
     def  a_					(			self		)       ->    Union[str, Any]:
          _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.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]     ,							UpperCAmelCase__     ,							atol=1e-3		)		)

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

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






     @slow
     def  a_					(			self		)       ->    Any:
          _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  a_					(			self		)       ->    str:
          _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  a_					(			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 unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin





class 						__SCREAMING_SNAKE_CASE					(      unittest.TestCase ,			lowerCamelCase__ ):






     def  a_					(			self		)       ->    Tuple:
          _a						=		load_tool("text-classification"		)
          self.tool.setup()
          _a						=		load_tool("text-classification"     ,							remote=__UpperCamelCase		)






     def  a_					(			self		)       ->    Optional[int]:
          _a						=		self.tool("That's quite cool"     ,							["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    Union[str, Any]:
          _a						=		self.remote_tool("That's quite cool"     ,							["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    Optional[int]:
          _a						=		self.tool(text="That's quite cool"     ,							labels=["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    str:
          _a						=		self.remote_tool(text="That's quite cool"     ,							labels=["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)

