






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


							'''simple docstring'''






							def __init__(		self			,			lowercase_			,			lowercase_=1_3			,			lowercase_=7			,			lowercase_=True			,			lowercase_=True			,			lowercase_=True			,			lowercase_=True			,			lowercase_=9_9			,			lowercase_=3_2			,			lowercase_=5			,			lowercase_=4			,			lowercase_=3_7			,			lowercase_="gelu"			,			lowercase_=0.1			,			lowercase_=0.1			,			lowercase_=5_1_2			,			lowercase_=1_6			,			lowercase_=2			,			lowercase_=0.02			,			lowercase_=3			,			lowercase_=None			,			lowercase_=2_0			,			lowercase_=3_0			,			lowercase_=2			,			lowercase_=2			,			lowercase_=1_0			,			)					->					List[str]:
														'''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_										=     scope
														lowerCAmelCase_										=     max_xpath_tag_unit_embeddings
														lowerCAmelCase_										=     max_xpath_subs_unit_embeddings
														lowerCAmelCase_										=     tag_pad_id
														lowerCAmelCase_										=     subs_pad_id
														lowerCAmelCase_										=     max_depth

							def      _lowercase       (		self   )					->					int:
														'''simple docstring'''

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

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

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

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

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

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

							def      _lowercase       (		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      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     MarkupLMModel(config=UpperCamelCase__   )
														model.to(UpperCamelCase__   )
														model.eval()
														print('Configs:'			,			model.config.tag_pad_id			,			model.config.subs_pad_id   )
														lowerCAmelCase_										=     model(UpperCamelCase__			,			attention_mask=UpperCamelCase__			,			token_type_ids=UpperCamelCase__   )
														lowerCAmelCase_										=     model(UpperCamelCase__			,			token_type_ids=UpperCamelCase__   )
														lowerCAmelCase_										=     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      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)					->					Union[str, Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     self.num_labels
														lowerCAmelCase_										=     MarkupLMForSequenceClassification(UpperCamelCase__   )
														model.to(UpperCamelCase__   )
														model.eval()
														lowerCAmelCase_										=     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      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     self.num_labels
														lowerCAmelCase_										=     MarkupLMForTokenClassification(config=UpperCamelCase__   )
														model.to(UpperCamelCase__   )
														model.eval()
														lowerCAmelCase_										=     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      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)					->					Tuple:
														'''simple docstring'''

														lowerCAmelCase_										=     MarkupLMForQuestionAnswering(config=UpperCamelCase__   )
														model.to(UpperCamelCase__   )
														model.eval()
														lowerCAmelCase_										=     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      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														lowerCAmelCase_										=     self.prepare_config_and_inputs()
														(
														    lowerCAmelCase_
														)										=     config_and_inputs
														lowerCAmelCase_										=     {
														    '''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_ (						__SCREAMING_SNAKE_CASE	,	__SCREAMING_SNAKE_CASE	,	unittest.TestCase		):


							'''simple docstring'''






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

							def      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_   )					->					Optional[Any]:
														'''simple docstring'''

														return True

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														lowerCAmelCase_										=     MarkupLMModelTester(self   )
														lowerCAmelCase_										=     ConfigTester(self			,			config_class=UpperCamelCase__			,			hidden_size=3_7   )

							def      _lowercase       (		self   )					->					Optional[int]:
														'''simple docstring'''

														self.config_tester.run_common_tests()

							def      _lowercase       (		self   )					->					List[Any]:
														'''simple docstring'''

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

							def      _lowercase       (		self   )					->					Optional[Any]:
														'''simple docstring'''

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

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

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






							def      _lowercase       (		self   )					->					Dict:
														'''simple docstring'''

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


def      lowerCamelCase					(						)	->			int:
							lowerCAmelCase_										=     '''
    <!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 							a_ (						unittest.TestCase		):


							'''simple docstring'''






							@cached_property
							def      _lowercase       (		self   )					->					Union[str, Any]:
														'''simple docstring'''

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

														return MarkupLMProcessor(UpperCamelCase__			,			UpperCamelCase__   )






							@slow
							def      _lowercase       (		self   )					->					Dict:
														'''simple docstring'''

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

														lowerCAmelCase_										=     self.default_processor

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

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

														# verify the last hidden states
														lowerCAmelCase_										=     torch.Size([1, 1_4, 7_6_8]   )
														self.assertEqual(outputs.last_hidden_state.shape			,			UpperCamelCase__   )

														lowerCAmelCase_										=     torch.tensor(
														    [[0.06_75, -0.00_52, 0.50_01], [-0.22_81, 0.08_02, 0.21_92], [-0.05_83, -0.33_11, 0.11_85]]   ).to(UpperCamelCase__   )

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





'''simple docstring'''
from __future__ import annotations

from collections.abc import Callable




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__ = 100      ,    )   ->				float:


		'''simple docstring'''


		snake_case   :    int			       =		x_start
		snake_case   :    Tuple			       =		fnc(SCREAMING_SNAKE_CASE__       )
		snake_case   :    Dict			       =		0.0

		for _ in range(SCREAMING_SNAKE_CASE__       ):
				# Approximates small segments of curve as linear and solve
				# for trapezoidal area
				snake_case   :    str			       =		(x_end - x_start) / steps + xa
				snake_case   :    str			       =		fnc(SCREAMING_SNAKE_CASE__       )
				area += abs(fxa + fxa       ) * (xa - xa) / 2

				# Increment step
				snake_case   :    Any			       =		xa
				snake_case   :    List[str]			       =		fxa
		return area


if __name__ == "__main__":




						def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__       )   ->				str:


								'''simple docstring'''


								return x**3

						print("f(x) = x^3")
						print("The area between the curve, x = -10, x = 10 and the x axis is:")
						lowercase__		    =	1_0
						while i <= 1_0_0_0_0_0:
												lowercase__		    =	trapezoidal_area(f, -5, 5, i)
												print(f"with {i} steps: {area}")
												i *= 1_0


