
"""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 SCREAMING_SNAKE_CASE       :






	'''simple docstring'''







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

			'''simple docstring'''






			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    _UpperCamelCase							(  self :Union[str, Any]			)			->   Optional[Any]:

			'''simple docstring'''






			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    _UpperCamelCase							(  self :List[Any]			)			->   int:

			'''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    _UpperCamelCase							(  self :Optional[int]       ,    __magic_name__ :List[str]       ,    __magic_name__ :List[str]       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[int]       ,    __magic_name__ :Optional[Any]       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[int]       ,    __magic_name__ :List[str]       ,    )			->   Any:

			'''simple docstring'''






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

			'''simple docstring'''






			a__   		=     self.num_labels
			a__   		=     MarkupLMForSequenceClassification(__magic_name__			)
			model.to(__magic_name__			)
			model.eval()
			a__   		=     model(
			    __magic_name__       ,    xpath_tags_seq=__magic_name__       ,    xpath_subs_seq=__magic_name__       ,    attention_mask=__magic_name__       ,    token_type_ids=__magic_name__       ,    labels=__magic_name__       ,    )
			self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, self.num_labels)			)


	def    _UpperCamelCase							(  self :Any       ,    __magic_name__ :Optional[int]       ,    __magic_name__ :Union[str, Any]       ,    __magic_name__ :List[str]       ,    __magic_name__ :List[str]       ,    __magic_name__ :List[Any]       ,    __magic_name__ :Union[str, Any]       ,    __magic_name__ :Dict       ,    __magic_name__ :Optional[Any]       ,    )			->   int:

			'''simple docstring'''






			a__   		=     self.num_labels
			a__   		=     MarkupLMForTokenClassification(config=__magic_name__			)
			model.to(__magic_name__			)
			model.eval()
			a__   		=     model(
			    __magic_name__       ,    xpath_tags_seq=__magic_name__       ,    xpath_subs_seq=__magic_name__       ,    attention_mask=__magic_name__       ,    token_type_ids=__magic_name__       ,    labels=__magic_name__       ,    )
			self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, self.seq_length, self.num_labels)			)


	def    _UpperCamelCase							(  self :Dict       ,    __magic_name__ :List[Any]       ,    __magic_name__ :Any       ,    __magic_name__ :Optional[Any]       ,    __magic_name__ :str       ,    __magic_name__ :List[str]       ,    __magic_name__ :Any       ,    __magic_name__ :List[str]       ,    __magic_name__ :List[str]       ,    )			->   Tuple:

			'''simple docstring'''






			a__   		=     MarkupLMForQuestionAnswering(config=__magic_name__			)
			model.to(__magic_name__			)
			model.eval()
			a__   		=     model(
			    __magic_name__       ,    xpath_tags_seq=__magic_name__       ,    xpath_subs_seq=__magic_name__       ,    attention_mask=__magic_name__       ,    token_type_ids=__magic_name__       ,    start_positions=__magic_name__       ,    end_positions=__magic_name__       ,    )
			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    _UpperCamelCase							(  self :int			)			->   Tuple:

			'''simple docstring'''






			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 SCREAMING_SNAKE_CASE       (      lowerCAmelCase					,   lowerCAmelCase					,   unittest.TestCase					):






	'''simple docstring'''







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


	def    _UpperCamelCase							(  self :int       ,    __magic_name__ :int       ,    __magic_name__ :Any       ,    __magic_name__ :Dict       ,    __magic_name__ :Union[str, Any]       ,    __magic_name__ :Tuple			)			->   Any:

			'''simple docstring'''






			return True


	def    _UpperCamelCase							(  self :Optional[Any]			)			->   Optional[Any]:

			'''simple docstring'''






			a__   		=     MarkupLMModelTester(self			)
			a__   		=     ConfigTester(self       ,    config_class=__magic_name__       ,    hidden_size=37			)


	def    _UpperCamelCase							(  self :Tuple			)			->   List[Any]:

			'''simple docstring'''






			self.config_tester.run_common_tests()


	def    _UpperCamelCase							(  self :int			)			->   Tuple:

			'''simple docstring'''






			a__   		=     self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*__magic_name__			)


	def    _UpperCamelCase							(  self :Dict			)			->   List[Any]:

			'''simple docstring'''






			a__   		=     self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_sequence_classification(*__magic_name__			)


	def    _UpperCamelCase							(  self :List[str]			)			->   Tuple:

			'''simple docstring'''






			a__   		=     self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_token_classification(*__magic_name__			)






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

			'''simple docstring'''






			a__   		=     self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_question_answering(*__magic_name__			)

def __snake_case (      )       ->    List[Any]:


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






	'''simple docstring'''







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

			'''simple docstring'''






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

			return MarkupLMProcessor(__magic_name__       ,    __magic_name__			)






	@slow
	def    _UpperCamelCase							(  self :Optional[int]			)			->   List[str]:

			'''simple docstring'''






			a__   		=     MarkupLMModel.from_pretrained('''microsoft/markuplm-base'''			).to(__magic_name__			)

			a__   		=     self.default_processor

			a__   		=     processor(prepare_html_string()       ,    return_tensors='''pt'''			)
			a__   		=     inputs.to(__magic_name__			)

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

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

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

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






"""simple docstring"""




__lowerCAmelCase							:  Any 				=		{
    '''0''': 1,
    '''1''': 1,
    '''2''': 2,
    '''3''': 6,
    '''4''': 24,
    '''5''': 120,
    '''6''': 720,
    '''7''': 5040,
    '''8''': 40320,
    '''9''': 362880,
}

__lowerCAmelCase							:  List[Any] 				=		{145: 145}

__lowerCAmelCase							:  Any 				=		{
    145: 0,
    169: 3,
    36301: 3,
    1454: 3,
    871: 2,
    45361: 2,
    872: 2,
}

def __snake_case (      UpperCamelCase    )       ->    int:


		"""simple docstring"""





		if n in CACHE_SUM_DIGIT_FACTORIALS:
				return CACHE_SUM_DIGIT_FACTORIALS[n]
		a__   		=     sum(DIGIT_FACTORIALS[let] for let in str(UpperCamelCase    )    )
		a__   		=     ret
		return ret

def __snake_case (      UpperCamelCase						,					UpperCamelCase = None    )       ->    int:


		"""simple docstring"""





		a__   		=     previous or set()
		if n in CHAIN_LENGTH_CACHE:
				return CHAIN_LENGTH_CACHE[n]
		a__   		=     sum_digit_factorials(UpperCamelCase    )
		if next_number in previous:
				a__   		=     0
				return 0
		else:
				previous.add(UpperCamelCase    )
				a__   		=     1 + chain_length(UpperCamelCase						,					UpperCamelCase    )
				a__   		=     ret
				return ret

def __snake_case (      UpperCamelCase = 60						,					UpperCamelCase = 1_000_000    )       ->    int:


		"""simple docstring"""





		return sum(1 for i in range(1						,					UpperCamelCase    ) if chain_length(UpperCamelCase    ) == num_terms    )


if __name__ == "__main__":
					print(f"{solution() = }")




