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






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





         """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   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """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(a       )

         __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   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						str    ,							a						:						Tuple    ,							a						:						Optional[int]    ,							a						:						Optional[Any]    ,							a						:						int    ,							a						:						Optional[Any]    ,							a						:						Tuple    ,							a						:						List[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    TFLayoutLMModel(config=a       )

         __lowerCamelCase            =    model(a    ,							a    ,							attention_mask=a    ,							token_type_ids=a       )
         __lowerCamelCase            =    model(a    ,							a    ,							token_type_ids=a       )
         __lowerCamelCase            =    model(a    ,							a       )
         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						:						Optional[Any]    ,							a						:						Tuple    ,							a						:						str    ,							a						:						Tuple    ,							a						:						Tuple    ,							a						:						Dict    ,							a						:						Dict    ,							a						:						Any    ,							a						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase            =    TFLayoutLMForMaskedLM(config=a       )

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						int    ,							a						:						int    ,							a						:						Any    ,							a						:						List[str]    ,							a						:						List[Any]    ,							a						:						str    ,							a						:						Dict    ,							a						:						List[str]    ,							a						:						Optional[int]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.num_labels
         __lowerCamelCase            =    TFLayoutLMForSequenceClassification(config=a       )

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]    ,							a						:						Any    ,							a						:						Union[str, Any]    ,							a						:						str    ,							a						:						Union[str, Any]    ,							a						:						List[Any]    ,							a						:						Dict    ,							a						:						List[Any]    ,							a						:						str       ):





         """simple docstring"""



         __lowerCamelCase            =    self.num_labels
         __lowerCamelCase            =    TFLayoutLMForTokenClassification(config=a       )

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any    ,							a						:						List[Any]    ,							a						:						Any    ,							a						:						int    ,							a						:						List[Any]    ,							a						:						Dict    ,							a						:						List[str]    ,							a						:						Tuple    ,							a						:						Optional[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    TFLayoutLMForQuestionAnswering(config=a       )

         __lowerCamelCase            =    model(a    ,							a    ,							attention_mask=a    ,							token_type_ids=a       )
         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						:						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        a__ (  UpperCAmelCase__				,  UpperCAmelCase__				,  unittest.TestCase					):
     lowerCamelCase    :	Union[str, Any]				=(
         (
             TFLayoutLMModel,
             TFLayoutLMForMaskedLM,
             TFLayoutLMForTokenClassification,
             TFLayoutLMForSequenceClassification,
             TFLayoutLMForQuestionAnswering,
         )
         if is_tf_available()
         else ()
     )
     lowerCamelCase    :	Optional[Any]				=(
         {
             "feature-extraction": TFLayoutLMModel,
             "fill-mask": TFLayoutLMForMaskedLM,
             "text-classification": TFLayoutLMForSequenceClassification,
             "token-classification": TFLayoutLMForTokenClassification,
             "zero-shot": TFLayoutLMForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     lowerCamelCase    :	str				=False
     lowerCamelCase    :	Union[str, Any]				=True
     lowerCamelCase    :	Optional[int]				=1_0






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



         __lowerCamelCase            =    TFLayoutLMModelTester(self       )
         __lowerCamelCase            =    ConfigTester(self    ,							config_class=a    ,							hidden_size=37       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         self.config_tester.run_common_tests()






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*a       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*a       )






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



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






     @unittest.skip('''Onnx compliancy broke with TF 2.10'''       )
     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



         pass






def __lowerCAmelCase					(				)      ->       Optional[Any]:
    # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
    # fmt: off
    __lowerCamelCase            =    tf.convert_to_tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]							)  # 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],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]							)  # 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([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]							)  # noqa: E231
    # fmt: on

    return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class        a__ (  unittest.TestCase					):






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """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=a    ,							bbox=a    ,							attention_mask=a    ,							token_type_ids=a       )

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

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

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






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """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=a    ,							bbox=a    ,							attention_mask=a    ,							token_type_ids=a    ,							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    ,							a       )

         # test the shape of the logits
         __lowerCamelCase            =    outputs.logits
         __lowerCamelCase            =    (2, 2)
         self.assertEqual(logits.shape    ,							a       )






     @slow
     def   SCREAMING_SNAKE_CASE__  (					self						:						List[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=a    ,							bbox=a    ,							attention_mask=a    ,							token_type_ids=a    ,							labels=a       )

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






     @slow
     def   SCREAMING_SNAKE_CASE__  (					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=a    ,							bbox=a    ,							attention_mask=a    ,							token_type_ids=a       )

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

'''simple docstring'''




def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							)      ->       float:
    if digit_amount > 0:
        return round(number - int(UpperCamelCase__							)							,    UpperCamelCase__							)
    return number - int(UpperCamelCase__							)


if __name__ == "__main__":
  print(decimal_isolate(1.53, 0))
  print(decimal_isolate(35.345, 1))
  print(decimal_isolate(35.345, 2))
  print(decimal_isolate(35.345, 3))
  print(decimal_isolate(-14.789, 3))
  print(decimal_isolate(0, 2))
  print(decimal_isolate(-14.123, 1))
  print(decimal_isolate(-14.123, 2))
  print(decimal_isolate(-14.123, 3))
