






import unittest

from transformers import MarkupLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MarkupLMForQuestionAnswering,
      MarkupLMForSequenceClassification,
      MarkupLMForTokenClassification,
      MarkupLMModel,
  )

# TODO check dependencies
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizer




class      __SCREAMING_SNAKE_CASE					:


  """simple docstring"""


  def __init__( self      ,  UpperCamelCase__      ,  UpperCamelCase__=13      ,  UpperCamelCase__=7      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=99      ,  UpperCamelCase__=32      ,  UpperCamelCase__=5      ,  UpperCamelCase__=4      ,  UpperCamelCase__=37      ,  UpperCamelCase__="gelu"      ,  UpperCamelCase__=0.1      ,  UpperCamelCase__=0.1      ,  UpperCamelCase__=512      ,  UpperCamelCase__=16      ,  UpperCamelCase__=2      ,  UpperCamelCase__=0.02      ,  UpperCamelCase__=3      ,  UpperCamelCase__=None      ,  UpperCamelCase__=20      ,  UpperCamelCase__=30      ,  UpperCamelCase__=2      ,  UpperCamelCase__=2      ,  UpperCamelCase__=10      ,  ):






         """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_	    = scope
         a_	    = max_xpath_tag_unit_embeddings
         a_	    = max_xpath_subs_unit_embeddings
         a_	    = tag_pad_id
         a_	    = subs_pad_id
         a_	    = max_depth







  def       _a					( self  ):






         """simple docstring"""


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

         a_	    = ids_tensor(
             [self.batch_size, self.seq_length, self.max_depth]      ,  self.max_xpath_tag_unit_embeddings  )

         a_	    = ids_tensor(
             [self.batch_size, self.seq_length, self.max_depth]      ,  self.max_xpath_subs_unit_embeddings  )

         a_	    = None
         if self.use_input_mask:
                a_	    = ids_tensor([self.batch_size, self.seq_length]      ,  vocab_size=2  )

         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
         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_	    = self.get_config()

         return (
             config,
             input_ids,
             xpath_tags_seq,
             xpath_subs_seq,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
         )







  def       _a					( self  ):






         """simple docstring"""


         return MarkupLMConfig(
             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      ,  max_xpath_tag_unit_embeddings=self.max_xpath_tag_unit_embeddings      ,  max_xpath_subs_unit_embeddings=self.max_xpath_subs_unit_embeddings      ,  tag_pad_id=self.tag_pad_id      ,  subs_pad_id=self.subs_pad_id      ,  max_depth=self.max_depth      ,  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = MarkupLMModel(config=UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         print('Configs:'      ,  model.config.tag_pad_id      ,  model.config.subs_pad_id  )
         a_	    = model(UpperCamelCase__      ,  attention_mask=UpperCamelCase__      ,  token_type_ids=UpperCamelCase__  )
         a_	    = model(UpperCamelCase__      ,  token_type_ids=UpperCamelCase__  )
         a_	    = model(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__      ,  ):






         """simple docstring"""


         a_	    = self.num_labels
         a_	    = MarkupLMForSequenceClassification(UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(
             UpperCamelCase__      ,  xpath_tags_seq=UpperCamelCase__      ,  xpath_subs_seq=UpperCamelCase__      ,  attention_mask=UpperCamelCase__      ,  token_type_ids=UpperCamelCase__      ,  labels=UpperCamelCase__      ,  )
         self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels)  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  ):






         """simple docstring"""


         a_	    = self.num_labels
         a_	    = MarkupLMForTokenClassification(config=UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(
             UpperCamelCase__      ,  xpath_tags_seq=UpperCamelCase__      ,  xpath_subs_seq=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__      ,  ):






         """simple docstring"""


         a_	    = MarkupLMForQuestionAnswering(config=UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(
             UpperCamelCase__      ,  xpath_tags_seq=UpperCamelCase__      ,  xpath_subs_seq=UpperCamelCase__      ,  attention_mask=UpperCamelCase__      ,  token_type_ids=UpperCamelCase__      ,  start_positions=UpperCamelCase__      ,  end_positions=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  ):






         """simple docstring"""


         a_	    = self.prepare_config_and_inputs()
         (
             a_	
         )	    = config_and_inputs
         a_	    = {
             '''input_ids''': input_ids,
             '''xpath_tags_seq''': xpath_tags_seq,
             '''xpath_subs_seq''': xpath_subs_seq,
             '''token_type_ids''': token_type_ids,
             '''attention_mask''': input_mask,
         }
         return config, inputs_dict





@require_torch
class      __SCREAMING_SNAKE_CASE					(A_       ,					A_       ,					unittest.TestCase					):


  """simple docstring"""


  _a     :   List[Any]			 =    (
      (
          MarkupLMModel,
          MarkupLMForSequenceClassification,
          MarkupLMForTokenClassification,
          MarkupLMForQuestionAnswering,
      )
      if is_torch_available()
      else None
  )
  _a     :   Any			 =    (
      {
          '''feature-extraction''': MarkupLMModel,
          '''question-answering''': MarkupLMForQuestionAnswering,
          '''text-classification''': MarkupLMForSequenceClassification,
          '''token-classification''': MarkupLMForTokenClassification,
          '''zero-shot''': MarkupLMForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         return True







  def       _a					( self  ):






         """simple docstring"""


         a_	    = MarkupLMModelTester(self  )
         a_	    = ConfigTester(self      ,  config_class=UpperCamelCase__      ,  hidden_size=37  )







  def       _a					( self  ):






         """simple docstring"""


         self.config_tester.run_common_tests()







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__  )





def 			__UpperCamelCase				(			):
       """simple docstring"""




       a_	    = '''
    <!DOCTYPE html>
    <html>
    <head>
    <title>Page Title</title>
    </head>
    <body>

    <h1>This is a Heading</h1>
    <p>This is a paragraph.</p>

    </body>
    </html>
    '''

       return html_string




@require_torch
class      __SCREAMING_SNAKE_CASE					(unittest.TestCase					):


  """simple docstring"""


  @cached_property
  def       _a					( self  ):






         """simple docstring"""


         a_	    = MarkupLMFeatureExtractor()
         a_	    = MarkupLMTokenizer.from_pretrained('microsoft/markuplm-base'  )

         return MarkupLMProcessor(UpperCamelCase__      ,  UpperCamelCase__  )







  @slow
  def       _a					( self  ):






         """simple docstring"""


         a_	    = MarkupLMModel.from_pretrained('microsoft/markuplm-base'  ).to(UpperCamelCase__  )

         a_	    = self.default_processor

         a_	    = processor(prepare_html_string()      ,  return_tensors='pt'  )
         a_	    = inputs.to(UpperCamelCase__  )

         # forward pass
         with torch.no_grad():
                a_	    = model(**UpperCamelCase__  )

         # verify the last hidden states
         a_	    = torch.Size([1, 14, 768]  )
         self.assertEqual(outputs.last_hidden_state.shape      ,  UpperCamelCase__  )

         a_	    = torch.tensor(
             [[0.0_675, -0.0_052, 0.5_001], [-0.2_281, 0.0_802, 0.2_192], [-0.0_583, -0.3_311, 0.1_185]]  ).to(UpperCamelCase__  )

         self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]      ,  UpperCamelCase__      ,  atol=1e-4  )  )












'''simple docstring'''







def 			__UpperCamelCase				(			lowercase_					:     int      ):
       """simple docstring"""




       if not isinstance(lowercase_      ,					lowercase_      ):
              raise ValueError('double_factorial() only accepts integral values'      )
       if num < 0:
              raise ValueError('double_factorial() not defined for negative values'      )
       a_	    = 1
       for i in range(lowercase_      ,					0      ,					-2      ):
              value *= i
       return value


if __name__ == "__main__":
  import doctest

  doctest.testmod()




