



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 			__snake_case   :







							'''simple docstring'''






							def __init__(				self	,	a_	,	a_=13	,	a_=7	,	a_=True	,	a_=True	,	a_=True	,	a_=True	,	a_=99	,	a_=32	,	a_=5	,	a_=4	,	a_=37	,	a_="gelu"	,	a_=0.1	,	a_=0.1	,	a_=512	,	a_=16	,	a_=2	,	a_=0.02	,	a_=3	,	a_=None	,	a_=20	,	a_=30	,	a_=2	,	a_=2	,	a_=10	,	):
											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		):
											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		):
											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	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	):
											a__					   =		MarkupLMModel(config=a_		)
											model.to(a_		)
											model.eval()
											print("""Configs:"""	,	model.config.tag_pad_id	,	model.config.subs_pad_id		)
											a__					   =		model(a_	,	attention_mask=a_	,	token_type_ids=a_		)
											a__					   =		model(a_	,	token_type_ids=a_		)
											a__					   =		model(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 _a   (				self	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	):
											a__					   =		self.num_labels
											a__					   =		MarkupLMForSequenceClassification(a_		)
											model.to(a_		)
											model.eval()
											a__					   =		model(
											    a_	,	xpath_tags_seq=a_	,	xpath_subs_seq=a_	,	attention_mask=a_	,	token_type_ids=a_	,	labels=a_	,	)
											self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.num_labels)		)


							def _a   (				self	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	):
											a__					   =		self.num_labels
											a__					   =		MarkupLMForTokenClassification(config=a_		)
											model.to(a_		)
											model.eval()
											a__					   =		model(
											    a_	,	xpath_tags_seq=a_	,	xpath_subs_seq=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 _a   (				self	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	a_	,	):
											a__					   =		MarkupLMForQuestionAnswering(config=a_		)
											model.to(a_		)
											model.eval()
											a__					   =		model(
											    a_	,	xpath_tags_seq=a_	,	xpath_subs_seq=a_	,	attention_mask=a_	,	token_type_ids=a_	,	start_positions=a_	,	end_positions=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 _a   (				self		):
											a__					   =		self.prepare_config_and_inputs()
											(
											    (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    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 			__snake_case   ( SCREAMING_SNAKE_CASE      ,SCREAMING_SNAKE_CASE      ,unittest.TestCase):







							'''simple docstring'''






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


							def _a   (				self	,	a_	,	a_	,	a_	,	a_	,	a_		):
											# ValueError: Nodes must be of type `List[str]` (single pretokenized example), or `List[List[str]]`
											# (batch of pretokenized examples).
											return True


							def _a   (				self		):
											a__					   =		MarkupLMModelTester(self		)
											a__					   =		ConfigTester(self	,	config_class=a_	,	hidden_size=37		)


							def _a   (				self		):
											self.config_tester.run_common_tests()


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*a_		)


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*a_		)


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*a_		)







							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*a_		)




def       A_   (						):

				"""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 			__snake_case   ( unittest.TestCase):







							'''simple docstring'''






							@cached_property
							def _a   (				self		):
											# TODO use from_pretrained here
											a__					   =		MarkupLMFeatureExtractor()
											a__					   =		MarkupLMTokenizer.from_pretrained("""microsoft/markuplm-base"""		)

											return MarkupLMProcessor(a_	,	a_		)







							@slow
							def _a   (				self		):
											a__					   =		MarkupLMModel.from_pretrained("""microsoft/markuplm-base"""		).to(a_		)

											a__					   =		self.default_processor

											a__					   =		processor(prepare_html_string()	,	return_tensors="""pt"""		)
											a__					   =		inputs.to(a_		)

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

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

											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(a_		)

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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCamelCase   	=  {'''configuration_visual_bert''': ['''VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VisualBertConfig''']}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCamelCase   	=  [
           '''VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''VisualBertForMultipleChoice''',
           '''VisualBertForPreTraining''',
           '''VisualBertForQuestionAnswering''',
           '''VisualBertForRegionToPhraseAlignment''',
           '''VisualBertForVisualReasoning''',
           '''VisualBertLayer''',
           '''VisualBertModel''',
           '''VisualBertPreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_visual_bert import (
                  VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VisualBertForMultipleChoice,
                  VisualBertForPreTraining,
                  VisualBertForQuestionAnswering,
                  VisualBertForRegionToPhraseAlignment,
                  VisualBertForVisualReasoning,
                  VisualBertLayer,
                  VisualBertModel,
                  VisualBertPreTrainedModel,
              )


else:
       import sys

       __lowerCamelCase   	=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



