


"""simple docstring"""







from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


lowerCamelCase_  :  List[Any]     		=    logging.get_logger(__name__)

lowerCamelCase_  :  int     		=    {
    """google/bigbird-pegasus-large-arxiv""": (
        """https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json"""
    ),
    """google/bigbird-pegasus-large-pubmed""": (
        """https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json"""
    ),
    """google/bigbird-pegasus-large-bigpatent""": (
        """https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json"""
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}






class  __A							(			lowerCamelCase__     ):






 """simple docstring"""




 __lowerCAmelCase					   =    'bigbird_pegasus'
 __lowerCAmelCase					   =    ['past_key_values']
 __lowerCAmelCase					   =    {
     'num_attention_heads': 'encoder_attention_heads',
     'hidden_size': 'd_model',
     'attention_probs_dropout_prob': 'attention_dropout',
 }


 def __init__(						self					,       __A=9_6103					,       __A=4096					,       __A=16					,       __A=4096					,       __A=16					,       __A=16					,       __A=4096					,       __A=16					,       __A=0.0					,       __A=0.0					,       __A=True					,       __A=True					,       __A="gelu_new"					,       __A=1024					,       __A=0.1					,       __A=0.0					,       __A=0.0					,       __A=0.02					,       __A=2					,       __A=0.0					,       __A=True					,       __A=0					,       __A=2					,       __A=1					,       __A="block_sparse"					,       __A=64					,       __A=3					,       __A=False					,       **__A					,       )   ->	int:
     a											=vocab_size
     a											=max_position_embeddings
     a											=d_model
     a											=encoder_ffn_dim
     a											=encoder_layers
     a											=encoder_attention_heads
     a											=decoder_ffn_dim
     a											=decoder_layers
     a											=decoder_attention_heads
     a											=dropout
     a											=attention_dropout
     a											=activation_dropout
     a											=activation_function
     a											=init_std
     a											=encoder_layerdrop
     a											=decoder_layerdrop
     a											=classifier_dropout
     a											=use_cache
     a											=encoder_layers
     a											=scale_embedding  # scale factor will be sqrt(d_model) if True

     # extra config
     a											=attention_type
     a											=block_size
     a											=num_random_blocks
     a											=use_bias

     super().__init__(
         pad_token_id=lowercase_					,       bos_token_id=lowercase_					,       eos_token_id=lowercase_					,       is_encoder_decoder=lowercase_					,       decoder_start_token_id=lowercase_					,       **lowercase_					,       )






class  __A							(			lowerCamelCase__     ):






 """simple docstring"""




 @property
 def  SCREAMING_SNAKE_CASE				(						self		)   ->	Mapping[str, Mapping[int, str]]:






     if self.task in ["default", "seq2seq-lm"]:
         a											=OrderedDict(
             [
                 ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
             ]		)

         if self.use_past:
             a											={0: '''batch'''}
             a											={0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
         else:
             a											={0: '''batch''', 1: '''decoder_sequence'''}
             a											={0: '''batch''', 1: '''decoder_sequence'''}

         if self.use_past:
             self.fill_with_past_key_values_(lowercase_					,       direction='''inputs'''		)
     elif self.task == "causal-lm":
         # TODO: figure this case out.
         a											=OrderedDict(
             [
                 ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
             ]		)
         if self.use_past:
             a						, a											=self.num_layers
             for i in range(lowercase_		):
                 a											={0: '''batch''', 2: '''past_sequence + sequence'''}
                 a											={0: '''batch''', 2: '''past_sequence + sequence'''}
     else:
         a											=OrderedDict(
             [
                 ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
                 ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
             ]		)

     return common_inputs


 @property
 def  SCREAMING_SNAKE_CASE				(						self		)   ->	Mapping[str, Mapping[int, str]]:






     if self.task in ["default", "seq2seq-lm"]:
         a											=super().outputs
     else:
         a											=super(lowercase_					,       self		).outputs
         if self.use_past:
             a						, a											=self.num_layers
             for i in range(lowercase_		):
                 a											={0: '''batch''', 2: '''past_sequence + sequence'''}
                 a											={0: '''batch''', 2: '''past_sequence + sequence'''}
     return common_outputs


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A = -1					,       __A = -1					,       __A = False					,       __A = None					,       )   ->	Mapping[str, Any]:
     a											=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_		)

     # Generate decoder inputs
     a											=seq_length if not self.use_past else 1
     a											=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_		)
     a											={f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
     a											=dict(**lowercase_					,       **lowercase_		)

     if self.use_past:
         if not is_torch_available():
             raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
         else:
             import torch
         a						, a											=common_inputs['''input_ids'''].shape
         a											=common_inputs['''decoder_input_ids'''].shape[1]
         a						, a											=self.num_attention_heads
         a											=(
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         a											=decoder_seq_length + 3
         a											=(
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )

         a											=torch.cat(
             [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase_					,       lowercase_		)]					,       dim=1		)

         a											=[]
         # If the number of encoder and decoder layers are present in the model configuration, both are considered
         a						, a											=self.num_layers
         a											=min(lowercase_					,       lowercase_		)
         a											=max(lowercase_					,       lowercase_		) - min_num_layers
         a											='''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

         for _ in range(lowercase_		):
             common_inputs["past_key_values"].append(
                 (
                     torch.zeros(lowercase_		),
                     torch.zeros(lowercase_		),
                     torch.zeros(lowercase_		),
                     torch.zeros(lowercase_		),
                 )		)
         # TODO: test this.
         a											=encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
         for _ in range(lowercase_					,       lowercase_		):
             common_inputs["past_key_values"].append((torch.zeros(lowercase_		), torch.zeros(lowercase_		))		)
     return common_inputs


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A = -1					,       __A = -1					,       __A = False					,       __A = None					,       )   ->	Mapping[str, Any]:
     a											=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_		)

     if self.use_past:
         if not is_torch_available():
             raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
         else:
             import torch
         a						, a											=common_inputs['''input_ids'''].shape
         # Not using the same length for past_key_values
         a											=seqlen + 2
         a						, a											=self.num_layers
         a						, a											=self.num_attention_heads
         a											=(
             batch,
             num_encoder_attention_heads,
             past_key_values_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )

         a											=common_inputs['''attention_mask'''].dtype
         a											=torch.cat(
             [common_inputs['''attention_mask'''], torch.ones(lowercase_					,       lowercase_					,       dtype=lowercase_		)]					,       dim=1		)
         a											=[
             (torch.zeros(lowercase_		), torch.zeros(lowercase_		)) for _ in range(lowercase_		)
         ]
     return common_inputs


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A = -1					,       __A = -1					,       __A = False					,       __A = None					,       )   ->	Mapping[str, Any]:
     a											=compute_effective_axis_dimension(
         lowercase_					,       fixed_dimension=OnnxConfig.default_fixed_batch					,       num_token_to_add=0		)

     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     a											=tokenizer.num_special_tokens_to_add(lowercase_		)
     a											=compute_effective_axis_dimension(
         lowercase_					,       fixed_dimension=OnnxConfig.default_fixed_sequence					,       num_token_to_add=lowercase_		)

     # Generate dummy inputs according to compute batch and sequence
     a											=[''' '''.join([tokenizer.unk_token]		) * seq_length] * batch_size
     a											=dict(tokenizer(lowercase_					,       return_tensors=lowercase_		)		)
     return common_inputs


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A = -1					,       __A = -1					,       __A = False					,       __A = None					,       )   ->	Mapping[str, Any]:






     if self.task in ["default", "seq2seq-lm"]:
         a											=self._generate_dummy_inputs_for_default_and_seqaseq_lm(
             lowercase_					,       batch_size=lowercase_					,       seq_length=lowercase_					,       is_pair=lowercase_					,       framework=lowercase_		)

     elif self.task == "causal-lm":
         a											=self._generate_dummy_inputs_for_causal_lm(
             lowercase_					,       batch_size=lowercase_					,       seq_length=lowercase_					,       is_pair=lowercase_					,       framework=lowercase_		)
     else:
         a											=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             lowercase_					,       batch_size=lowercase_					,       seq_length=lowercase_					,       is_pair=lowercase_					,       framework=lowercase_		)

     return common_inputs





 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A					,       __A		)   ->	str:






     if self.task in ["default", "seq2seq-lm"]:
         a											=super()._flatten_past_key_values_(lowercase_					,       lowercase_					,       lowercase_					,       lowercase_		)
     else:
         a											=super(lowercase_					,       self		)._flatten_past_key_values_(
             lowercase_					,       lowercase_					,       lowercase_					,       lowercase_		)


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

   '''simple docstring'''




   def __init__(							self,       lowercase_,       lowercase_=13,       lowercase_=7,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=True,       lowercase_=99,       lowercase_=32,       lowercase_=5,       lowercase_=4,       lowercase_=37,       lowercase_="gelu",       lowercase_=0.1,       lowercase_=0.1,       lowercase_=512,       lowercase_=16,       lowercase_=2,       lowercase_=0.02,       lowercase_=3,       lowercase_=None,       lowercase_=20,       lowercase_=30,       lowercase_=2,       lowercase_=2,       lowercase_=10,       )				->       Dict:






     """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			)				->       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[str]:






     """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,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =MarkupLMModel(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     print('''Configs:''',       model.config.tag_pad_id,       model.config.subs_pad_id			)
     a__    =model(lowercase_,       attention_mask=lowercase_,       token_type_ids=lowercase_			)
     a__    =model(lowercase_,       token_type_ids=lowercase_			)
     a__    =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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Tuple:






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForSequenceClassification(lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Union[str, Any]:






     """simple docstring"""






     a__    =self.num_labels
     a__    =MarkupLMForTokenClassification(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =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 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       )				->       Any:






     """simple docstring"""






     a__    =MarkupLMForQuestionAnswering(config=lowercase_			)
     model.to(lowercase_			)
     model.eval()
     a__    =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 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """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 		__magic_name__     (				lowerCamelCase__						,			lowerCamelCase__						,			unittest.TestCase				):

   '''simple docstring'''




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



   def 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_,       lowercase_,       lowercase_,       lowercase_			)				->       Union[str, Any]:






     """simple docstring"""






     return True



   def 					_UpperCAmelCase					(							self			)				->       List[str]:






     """simple docstring"""






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



   def 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     self.config_tester.run_common_tests()



   def 					_UpperCAmelCase					(							self			)				->       List[str]:






     """simple docstring"""






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



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






     """simple docstring"""






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



   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






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



   def 					_UpperCAmelCase					(							self			)				->       int:






     """simple docstring"""






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





def      UpperCAmelCase__							(     ):





  '''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 		__magic_name__     (				unittest.TestCase				):

   '''simple docstring'''




   @cached_property
   def 					_UpperCAmelCase					(							self			)				->       List[str]:






     """simple docstring"""






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

     return MarkupLMProcessor(lowercase_,       lowercase_			)



   @slow
   def 					_UpperCAmelCase					(							self			)				->       Optional[Any]:






     """simple docstring"""






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

     a__    =self.default_processor

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

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

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

     a__    =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			)			)
