

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     _UpperCAmelCase			:
			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=5_12      ,		_A=16      ,		_A=2      ,		_A=0.02      ,		_A=3      ,		_A=None      ,		_A=20      ,		_A=30      ,		_A=2      ,		_A=2      ,		_A=10      ,		)    ->    Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					parent
				_UpperCAmelCase    :							List[str]									=					batch_size
				_UpperCAmelCase    :							str									=					seq_length
				_UpperCAmelCase    :							str									=					is_training
				_UpperCAmelCase    :							Optional[Any]									=					use_input_mask
				_UpperCAmelCase    :							Any									=					use_token_type_ids
				_UpperCAmelCase    :							str									=					use_labels
				_UpperCAmelCase    :							int									=					vocab_size
				_UpperCAmelCase    :							Tuple									=					hidden_size
				_UpperCAmelCase    :							str									=					num_hidden_layers
				_UpperCAmelCase    :							str									=					num_attention_heads
				_UpperCAmelCase    :							Optional[int]									=					intermediate_size
				_UpperCAmelCase    :							Tuple									=					hidden_act
				_UpperCAmelCase    :							Any									=					hidden_dropout_prob
				_UpperCAmelCase    :							Tuple									=					attention_probs_dropout_prob
				_UpperCAmelCase    :							str									=					max_position_embeddings
				_UpperCAmelCase    :							List[Any]									=					type_vocab_size
				_UpperCAmelCase    :							str									=					type_sequence_label_size
				_UpperCAmelCase    :							Any									=					initializer_range
				_UpperCAmelCase    :							Optional[Any]									=					num_labels
				_UpperCAmelCase    :							Union[str, Any]									=					scope
				_UpperCAmelCase    :							int									=					max_xpath_tag_unit_embeddings
				_UpperCAmelCase    :							Any									=					max_xpath_subs_unit_embeddings
				_UpperCAmelCase    :							Union[str, Any]									=					tag_pad_id
				_UpperCAmelCase    :							Union[str, Any]									=					subs_pad_id
				_UpperCAmelCase    :							int									=					max_depth
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size     )

				_UpperCAmelCase    :							Any									=					ids_tensor(
				    [self.batch_size, self.seq_length, self.max_depth]      ,		self.max_xpath_tag_unit_embeddings     )

				_UpperCAmelCase    :							Tuple									=					ids_tensor(
				    [self.batch_size, self.seq_length, self.max_depth]      ,		self.max_xpath_subs_unit_embeddings     )

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

				_UpperCAmelCase    :							int									=					None
				if self.use_token_type_ids:
					_UpperCAmelCase    :							List[Any]									=					ids_tensor([self.batch_size, self.seq_length]      ,		self.type_vocab_size     )

				_UpperCAmelCase    :							List[Any]									=					None
				_UpperCAmelCase    :							int									=					None
				if self.use_labels:
					_UpperCAmelCase    :							Optional[int]									=					ids_tensor([self.batch_size]      ,		self.type_sequence_label_size     )
					_UpperCAmelCase    :							Optional[int]									=					ids_tensor([self.batch_size, self.seq_length]      ,		self.num_labels     )

				_UpperCAmelCase    :							Tuple									=					self.get_config()

				return (
				    config,
				    input_ids,
				    xpath_tags_seq,
				    xpath_subs_seq,
				    token_type_ids,
				    input_mask,
				    sequence_labels,
				    token_labels,
				)
			def 							__snake_case (		self     )    ->    Tuple:






				'''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 							__snake_case (		self      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		)    ->    Optional[Any]:






				'''simple docstring'''







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






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					self.num_labels
				_UpperCAmelCase    :							List[str]									=					MarkupLMForSequenceClassification(lowercase_     )
				model.to(lowercase_     )
				model.eval()
				_UpperCAmelCase    :							Optional[int]									=					model(
				    lowercase_      ,		xpath_tags_seq=lowercase_      ,		xpath_subs_seq=lowercase_      ,		attention_mask=lowercase_      ,		token_type_ids=lowercase_      ,		labels=lowercase_      ,		)
				self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_labels)     )
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		)    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					self.num_labels
				_UpperCAmelCase    :							Dict									=					MarkupLMForTokenClassification(config=lowercase_     )
				model.to(lowercase_     )
				model.eval()
				_UpperCAmelCase    :							List[str]									=					model(
				    lowercase_      ,		xpath_tags_seq=lowercase_      ,		xpath_subs_seq=lowercase_      ,		attention_mask=lowercase_      ,		token_type_ids=lowercase_      ,		labels=lowercase_      ,		)
				self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.seq_length, self.num_labels)     )
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		)    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					MarkupLMForQuestionAnswering(config=lowercase_     )
				model.to(lowercase_     )
				model.eval()
				_UpperCAmelCase    :							Optional[int]									=					model(
				    lowercase_      ,		xpath_tags_seq=lowercase_      ,		xpath_subs_seq=lowercase_      ,		attention_mask=lowercase_      ,		token_type_ids=lowercase_      ,		start_positions=lowercase_      ,		end_positions=lowercase_      ,		)
				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 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







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






				'''simple docstring'''







				return True
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					MarkupLMModelTester(self     )
				_UpperCAmelCase    :							Dict									=					ConfigTester(self      ,		config_class=lowercase_      ,		hidden_size=37     )
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







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






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowercase_     )
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_sequence_classification(*lowercase_     )
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_token_classification(*lowercase_     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_question_answering(*lowercase_     )
def       UpperCamelCase					(			)				->			Any:
	_UpperCAmelCase    :							Tuple									=					'''
    <!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     _UpperCAmelCase			(		unittest.TestCase):
			@cached_property
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					MarkupLMFeatureExtractor()
				_UpperCAmelCase    :							Any									=					MarkupLMTokenizer.from_pretrained("""microsoft/markuplm-base"""     )

				return MarkupLMProcessor(lowercase_      ,		lowercase_     )
			@slow
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					MarkupLMModel.from_pretrained("""microsoft/markuplm-base"""     ).to(lowercase_     )

				_UpperCAmelCase    :							Tuple									=					self.default_processor

				_UpperCAmelCase    :							Union[str, Any]									=					processor(prepare_html_string()      ,		return_tensors="""pt"""     )
				_UpperCAmelCase    :							List[Any]									=					inputs.to(lowercase_     )

				# forward pass
				with torch.no_grad():
					_UpperCAmelCase    :							List[str]									=					model(**lowercase_     )

				# verify the last hidden states
				_UpperCAmelCase    :							Union[str, Any]									=					torch.Size([1, 14, 7_68]     )
				self.assertEqual(outputs.last_hidden_state.shape      ,		lowercase_     )

				_UpperCAmelCase    :							List[str]									=					torch.tensor(
				    [[0.0675, -0.0052, 0.5001], [-0.2281, 0.0802, 0.2192], [-0.0583, -0.3311, 0.1185]]     ).to(lowercase_     )

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








"""simple docstring"""






def       UpperCamelCase					(			_lowerCAmelCase     :						float,  _lowerCAmelCase     :						float )				->			float:
	_UpperCAmelCase    :							List[Any]									=					float()
	try:
		_UpperCAmelCase    :							Optional[Any]									=					mass * acceleration
	except Exception:
		return -0.0
	return force


if __name__ == "__main__":
						import doctest

						# run doctest
						doctest.testmod()

						# demo
						lowerCamelCase__				:  Any													=  12.5
						lowerCamelCase__				:  Union[str, Any]													=  10
						lowerCamelCase__				:  Optional[Any]													=  newtons_second_law_of_motion(mass, acceleration)
						print('''The force is ''', force, '''N''')





