
'''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      snake_case__    :







		"""simple docstring"""

		def __init__(	self							:       List[str]   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       Optional[int]=13   ,     UpperCamelCase__							:       List[str]=7   ,     UpperCamelCase__							:       Any=True   ,     UpperCamelCase__							:       int=True   ,     UpperCamelCase__							:       Union[str, Any]=True   ,     UpperCamelCase__							:       Optional[int]=True   ,     UpperCamelCase__							:       Tuple=99   ,     UpperCamelCase__							:       Tuple=32   ,     UpperCamelCase__							:       Optional[int]=5   ,     UpperCamelCase__							:       Optional[int]=4   ,     UpperCamelCase__							:       List[str]=37   ,     UpperCamelCase__							:       List[Any]="gelu"   ,     UpperCamelCase__							:       Union[str, Any]=0.1   ,     UpperCamelCase__							:       Dict=0.1   ,     UpperCamelCase__							:       Union[str, Any]=512   ,     UpperCamelCase__							:       Optional[Any]=16   ,     UpperCamelCase__							:       Any=2   ,     UpperCamelCase__							:       str=0.02   ,     UpperCamelCase__							:       List[Any]=3   ,     UpperCamelCase__							:       List[str]=None   ,     UpperCamelCase__							:       Tuple=20   ,     UpperCamelCase__							:       Tuple=30   ,     UpperCamelCase__							:       Optional[int]=2   ,     UpperCamelCase__							:       Any=2   ,     UpperCamelCase__							:       int=10   ,     )		->       List[str]:






				"""simple docstring"""







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



		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       int:






				"""simple docstring"""







				snake_case   :    int			       =		ids_tensor([self.batch_size, self.seq_length]   ,     self.vocab_size	)

				snake_case   :    List[str]			       =		ids_tensor(
				    [self.batch_size, self.seq_length, self.max_depth]   ,     self.max_xpath_tag_unit_embeddings	)

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

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

				snake_case   :    Tuple			       =		None
				if self.use_token_type_ids:
						snake_case   :    Dict			       =		ids_tensor([self.batch_size, self.seq_length]   ,     self.type_vocab_size	)

				snake_case   :    Union[str, Any]			       =		None
				snake_case   :    List[str]			       =		None
				if self.use_labels:
						snake_case   :    str			       =		ids_tensor([self.batch_size]   ,     self.type_sequence_label_size	)
						snake_case   :    List[str]			       =		ids_tensor([self.batch_size, self.seq_length]   ,     self.num_labels	)

				snake_case   :    Dict			       =		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							:       List[str]	)		->       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 	lowerCAmelCase							(	self							:       Tuple   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       List[str]   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       List[str]   ,     UpperCamelCase__							:       Dict   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       List[Any]   ,     )		->       str:






				"""simple docstring"""







				snake_case   :    Optional[int]			       =		MarkupLMModel(config=UpperCamelCase__	)
				model.to(UpperCamelCase__	)
				model.eval()
				print('''Configs:'''   ,     model.config.tag_pad_id   ,     model.config.subs_pad_id	)
				snake_case   :    Tuple			       =		model(UpperCamelCase__   ,     attention_mask=UpperCamelCase__   ,     token_type_ids=UpperCamelCase__	)
				snake_case   :    List[Any]			       =		model(UpperCamelCase__   ,     token_type_ids=UpperCamelCase__	)
				snake_case   :    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							:       str   ,     UpperCamelCase__							:       List[str]   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       List[Any]   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       List[Any]   ,     UpperCamelCase__							:       List[Any]   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       Union[str, Any]   ,     )		->       Union[str, Any]:






				"""simple docstring"""







				snake_case   :    Tuple			       =		self.num_labels
				snake_case   :    List[str]			       =		MarkupLMForSequenceClassification(UpperCamelCase__	)
				model.to(UpperCamelCase__	)
				model.eval()
				snake_case   :    List[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.num_labels)	)



		def 	lowerCAmelCase							(	self							:       str   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       Dict   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       List[Any]   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       Dict   ,     )		->       str:






				"""simple docstring"""







				snake_case   :    Optional[int]			       =		self.num_labels
				snake_case   :    Tuple			       =		MarkupLMForTokenClassification(config=UpperCamelCase__	)
				model.to(UpperCamelCase__	)
				model.eval()
				snake_case   :    Dict			       =		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							:       str   ,     UpperCamelCase__							:       str   ,     UpperCamelCase__							:       Optional[Any]   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       Any   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       Union[str, Any]   ,     UpperCamelCase__							:       Union[str, Any]   ,     )		->       Tuple:






				"""simple docstring"""







				snake_case   :    List[Any]			       =		MarkupLMForQuestionAnswering(config=UpperCamelCase__	)
				model.to(UpperCamelCase__	)
				model.eval()
				snake_case   :    List[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							:       int	)		->       List[str]:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		self.prepare_config_and_inputs()
				(
				    (
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,(
				    snake_case
				)       ,
				)   :    Dict			       =		config_and_inputs
				snake_case   :    List[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      snake_case__    (	__SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , unittest.TestCase ):







		"""simple docstring"""

		lowerCamelCase							=		(
		    (
		        MarkupLMModel,
		        MarkupLMForSequenceClassification,
		        MarkupLMForTokenClassification,
		        MarkupLMForQuestionAnswering,
		    )
		    if is_torch_available()
		    else None
		)
		lowerCamelCase							=		(
		    {
		        """feature-extraction""": MarkupLMModel,
		        """question-answering""": MarkupLMForQuestionAnswering,
		        """text-classification""": MarkupLMForSequenceClassification,
		        """token-classification""": MarkupLMForTokenClassification,
		        """zero-shot""": MarkupLMForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)



		def 	lowerCAmelCase							(	self							:       List[str]   ,     UpperCamelCase__							:       str   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       Union[str, Any]	)		->       Optional[Any]:






				"""simple docstring"""







				return True



		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       List[str]:






				"""simple docstring"""







				snake_case   :    Optional[int]			       =		MarkupLMModelTester(self	)
				snake_case   :    Tuple			       =		ConfigTester(self   ,     config_class=UpperCamelCase__   ,     hidden_size=37	)



		def 	lowerCAmelCase							(	self							:       Optional[int]	)		->       Optional[int]:






				"""simple docstring"""







				self.config_tester.run_common_tests()



		def 	lowerCAmelCase							(	self							:       int	)		->       List[Any]:






				"""simple docstring"""







				snake_case   :    Any			       =		self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*UpperCamelCase__	)



		def 	lowerCAmelCase							(	self							:       Optional[int]	)		->       Optional[Any]:






				"""simple docstring"""







				snake_case   :    Union[str, Any]			       =		self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__	)



		def 	lowerCAmelCase							(	self							:       Optional[int]	)		->       List[str]:






				"""simple docstring"""







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



		def 	lowerCAmelCase							(	self							:       List[str]	)		->       Dict:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__	)







def 					_UpperCamelCase		(    )   ->				int:


		'''simple docstring'''


		snake_case   :    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      snake_case__    (	unittest.TestCase ):







		"""simple docstring"""

		@cached_property
		def 	lowerCAmelCase							(	self							:       List[Any]	)		->       Union[str, Any]:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		MarkupLMFeatureExtractor()
				snake_case   :    Optional[Any]			       =		MarkupLMTokenizer.from_pretrained('''microsoft/markuplm-base'''	)

				return MarkupLMProcessor(UpperCamelCase__   ,     UpperCamelCase__	)



		@slow
		def 	lowerCAmelCase							(	self							:       Union[str, Any]	)		->       Dict:






				"""simple docstring"""







				snake_case   :    str			       =		MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''	).to(UpperCamelCase__	)

				snake_case   :    Optional[int]			       =		self.default_processor

				snake_case   :    Optional[int]			       =		processor(prepare_html_string()   ,     return_tensors='''pt'''	)
				snake_case   :    Optional[int]			       =		inputs.to(UpperCamelCase__	)

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

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

				snake_case   :    Any			       =		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        a_				(							_lowercase = 10**6   ):

						if n <= 0:
												raise ValueError('''Please enter an integer greater than 0'''   )

						_UpperCamelCase			:					Any     =    list(range(n + 1   )   )
						for number in range(2       ,						n + 1   ):
												if phi[number] == number:
																		phi[number] -= 1
																		for multiple in range(number * 2       ,						n + 1       ,						_lowercase   ):
																								_UpperCamelCase			:					List[str]     =    (phi[multiple] // number) * (number - 1)

						_UpperCamelCase			:					Union[str, Any]     =    1
						for number in range(1       ,						n + 1   ):
												if (answer / phi[answer]) < (number / phi[number]):
																		_UpperCamelCase			:					List[str]     =    number

						return answer


if __name__ == "__main__":
						print(solution())



