

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


   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.0_2    ,       _UpperCamelCase=3    ,       _UpperCamelCase=None    ,       _UpperCamelCase=20    ,       _UpperCamelCase=30    ,       _UpperCamelCase=2    ,       _UpperCamelCase=2    ,       _UpperCamelCase=10    ,       ):





      """simple docstring"""





      _lowercase    :   int      =     parent
      _lowercase    :   Union[str, Any]      =     batch_size
      _lowercase    :   Union[str, Any]      =     seq_length
      _lowercase    :   Tuple      =     is_training
      _lowercase    :   Tuple      =     use_input_mask
      _lowercase    :   List[str]      =     use_token_type_ids
      _lowercase    :   Optional[int]      =     use_labels
      _lowercase    :   List[Any]      =     vocab_size
      _lowercase    :   List[str]      =     hidden_size
      _lowercase    :   Optional[Any]      =     num_hidden_layers
      _lowercase    :   Optional[int]      =     num_attention_heads
      _lowercase    :   List[Any]      =     intermediate_size
      _lowercase    :   Tuple      =     hidden_act
      _lowercase    :   Any      =     hidden_dropout_prob
      _lowercase    :   str      =     attention_probs_dropout_prob
      _lowercase    :   Optional[int]      =     max_position_embeddings
      _lowercase    :   Dict      =     type_vocab_size
      _lowercase    :   Optional[Any]      =     type_sequence_label_size
      _lowercase    :   str      =     initializer_range
      _lowercase    :   Dict      =     num_labels
      _lowercase    :   str      =     scope
      _lowercase    :   Optional[Any]      =     max_xpath_tag_unit_embeddings
      _lowercase    :   Tuple      =     max_xpath_subs_unit_embeddings
      _lowercase    :   Union[str, Any]      =     tag_pad_id
      _lowercase    :   Union[str, Any]      =     subs_pad_id
      _lowercase    :   Optional[Any]      =     max_depth


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   List[str]      =     ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size						)

      _lowercase    :   Tuple      =     ids_tensor(
          [self.batch_size, self.seq_length, self.max_depth]    ,       self.max_xpath_tag_unit_embeddings						)

      _lowercase    :   List[str]      =     ids_tensor(
          [self.batch_size, self.seq_length, self.max_depth]    ,       self.max_xpath_subs_unit_embeddings						)

      _lowercase    :   Optional[Any]      =     None
      if self.use_input_mask:
         _lowercase    :   str      =     ids_tensor([self.batch_size, self.seq_length]    ,       vocab_size=2						)

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

      _lowercase    :   str      =     None
      _lowercase    :   Dict      =     None
      if self.use_labels:
         _lowercase    :   Tuple      =     ids_tensor([self.batch_size]    ,       self.type_sequence_label_size						)
         _lowercase    :   List[str]      =     ids_tensor([self.batch_size, self.seq_length]    ,       self.num_labels						)

      _lowercase    :   Tuple      =     self.get_config()

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


   def 		_lowerCamelCase     (				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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       ):





      """simple docstring"""





      _lowercase    :   Dict      =     MarkupLMModel(config=_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      print("Configs:"    ,       model.config.tag_pad_id    ,       model.config.subs_pad_id						)
      _lowercase    :   Optional[Any]      =     model(_UpperCamelCase    ,       attention_mask=_UpperCamelCase    ,       token_type_ids=_UpperCamelCase						)
      _lowercase    :   str      =     model(_UpperCamelCase    ,       token_type_ids=_UpperCamelCase						)
      _lowercase    :   Dict      =     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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       ):





      """simple docstring"""





      _lowercase    :   Any      =     self.num_labels
      _lowercase    :   str      =     MarkupLMForSequenceClassification(_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      _lowercase    :   str      =     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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       ):





      """simple docstring"""





      _lowercase    :   Dict      =     self.num_labels
      _lowercase    :   Optional[Any]      =     MarkupLMForTokenClassification(config=_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      _lowercase    :   Optional[Any]      =     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 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       ):





      """simple docstring"""





      _lowercase    :   Tuple      =     MarkupLMForQuestionAnswering(config=_UpperCamelCase						)
      model.to(_UpperCamelCase						)
      model.eval()
      _lowercase    :   str      =     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 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Tuple      =     self.prepare_config_and_inputs()
      (
          (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   (
          _lowercase
      )  ,   
      )    :   str      =     config_and_inputs
      _lowercase    :   int      =     {
          "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      a__						(							lowerCamelCase_						,   lowerCamelCase_						,   unittest.TestCase						):
   _SCREAMING_SNAKE_CASE					:  Optional[int]			 =							(
       (
           MarkupLMModel,
           MarkupLMForSequenceClassification,
           MarkupLMForTokenClassification,
           MarkupLMForQuestionAnswering,
       )
       if is_torch_available()
       else None
   )
   _SCREAMING_SNAKE_CASE					:  Tuple			 =							(
       {
           'feature-extraction': MarkupLMModel,
           'question-answering': MarkupLMForQuestionAnswering,
           'text-classification': MarkupLMForSequenceClassification,
           'token-classification': MarkupLMForTokenClassification,
           'zero-shot': MarkupLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      return True


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Any      =     MarkupLMModelTester(self						)
      _lowercase    :   int      =     ConfigTester(self    ,       config_class=_UpperCamelCase    ,       hidden_size=37						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      self.config_tester.run_common_tests()


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Dict      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Tuple      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase						)


   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Union[str, Any]      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase						)






   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Optional[int]      =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase						)







def       _A	(			)    ->			Dict:
   _lowercase    :   int      =     "\n    <!DOCTYPE html>\n    <html>\n    <head>\n    <title>Page Title</title>\n    </head>\n    <body>\n\n    <h1>This is a Heading</h1>\n    <p>This is a paragraph.</p>\n\n    </body>\n    </html>\n    "

   return html_string


@require_torch
class      a__						(							unittest.TestCase						):


   @cached_property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Tuple      =     MarkupLMFeatureExtractor()
      _lowercase    :   Optional[int]      =     MarkupLMTokenizer.from_pretrained("microsoft/markuplm-base"						)

      return MarkupLMProcessor(_UpperCamelCase    ,       _UpperCamelCase						)






   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   str      =     MarkupLMModel.from_pretrained("microsoft/markuplm-base"						).to(_UpperCamelCase						)

      _lowercase    :   Dict      =     self.default_processor

      _lowercase    :   Optional[int]      =     processor(prepare_html_string()    ,       return_tensors="pt"						)
      _lowercase    :   Union[str, Any]      =     inputs.to(_UpperCamelCase						)

      # forward pass
      with torch.no_grad():
         _lowercase    :   Any      =     model(**_UpperCamelCase						)

      # verify the last hidden states
      _lowercase    :   Optional[Any]      =     torch.Size([1, 14, 768]						)
      self.assertEqual(outputs.last_hidden_state.shape    ,       _UpperCamelCase						)

      _lowercase    :   List[Any]      =     torch.tensor(
          [[0.0_6_7_5, -0.0_0_5_2, 0.5_0_0_1], [-0.2_2_8_1, 0.0_8_0_2, 0.2_1_9_2], [-0.0_5_8_3, -0.3_3_1_1, 0.1_1_8_5]]						).to(_UpperCamelCase						)

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









'''simple docstring'''
class      a__						:


   def __init__(				self    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Tuple      =     data
      _lowercase    :   int
      _lowercase    :   Node







def       _A	(			snake_case  )    ->			None:
   _lowercase    :   Any      =     0
   _lowercase    :   str      =     x







def       _A	(			snake_case	,							snake_case  )    ->			None:
   _lowercase  ,   _lowercase    :   Any      =     find_set(snake_case  ), find_set(snake_case  )
   if x == y:
      return

   elif x.rank > y.rank:
      _lowercase    :   Dict      =     x
   else:
      _lowercase    :   Optional[int]      =     y
      if x.rank == y.rank:
         y.rank += 1







def       _A	(			snake_case  )    ->			Node:
   if x != x.parent:
      _lowercase    :   Optional[int]      =     find_set(x.parent  )
   return x.parent







def       _A	(			snake_case  )    ->			set:
   _lowercase    :   Any      =     ({0, 1, 2}, {3, 4, 5})
   for s in sets:
      if node.data in s:
         return s
   _lowercase    :   List[Any]      =     F'''{node.data} is not in {sets}'''
   raise ValueError(snake_case  )







def       _A	(			)    ->			None:
   _lowercase    :   Union[str, Any]      =     [Node(snake_case  ) for i in range(6  )]
   for v in vertex:
      make_set(snake_case  )

   union_set(vertex[0]	,							vertex[1]  )
   union_set(vertex[1]	,							vertex[2]  )
   union_set(vertex[3]	,							vertex[4]  )
   union_set(vertex[3]	,							vertex[5]  )

   for nodea in vertex:
      for nodea in vertex:
         if find_python_set(snake_case  ).isdisjoint(find_python_set(snake_case  )  ):
            assert find_set(snake_case  ) != find_set(snake_case  )
         else:
            assert find_set(snake_case  ) == find_set(snake_case  )


if __name__ == "__main__":
    test_disjoint_set()






