






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






      '''simple docstring'''




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




       """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    __lowerCAmelCase      (   self   :		List[Any]						)					->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   :		List[str]				,      __UpperCAmelCase   :		Tuple				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		Tuple				,      __UpperCAmelCase   :		List[Any]				,      __UpperCAmelCase   :		Tuple				,      __UpperCAmelCase   :		List[Any]				,      __UpperCAmelCase   :		Optional[Any]				,      __UpperCAmelCase   :		Any				,      )					->Optional[Any]:




       """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    __lowerCAmelCase      (   self   :		Dict				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		Optional[int]				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		Tuple				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		Union[str, Any]				,      __UpperCAmelCase   :		Optional[int]				,      )					->Any:




       """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    __lowerCAmelCase      (   self   :		Optional[Any]				,      __UpperCAmelCase   :		str				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		Optional[int]				,      __UpperCAmelCase   :		str				,      __UpperCAmelCase   :		Union[str, Any]				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		Any				,      )					->Optional[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    __lowerCAmelCase      (   self   :		List[str]				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		Optional[Any]				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		Optional[int]				,      __UpperCAmelCase   :		Tuple				,      __UpperCAmelCase   :		str				,      __UpperCAmelCase   :		Union[str, Any]				,      )					->Tuple:




       """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    __lowerCAmelCase      (   self   :		int						)					->Optional[Any]:




       """simple docstring"""


       a							=   self.prepare_config_and_inputs()
       (
           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 	lowercase_      (			__UpperCAmelCase				,						__UpperCAmelCase				,						unittest.TestCase     ):






      '''simple docstring'''




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







      def    __lowerCAmelCase      (   self   :		Optional[Any]				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		str				,      __UpperCAmelCase   :		Optional[int]				,      __UpperCAmelCase   :		int				,      __UpperCAmelCase   :		List[str]						)					->List[str]:




       """simple docstring"""


       return True







      def    __lowerCAmelCase      (   self   :		Dict						)					->Optional[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


       self.config_tester.run_common_tests()







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      def    __lowerCAmelCase      (   self   :		Any						)					->str:




       """simple docstring"""


       a							=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*lowercase_						)
def 		_a					(   )							->    Any:
 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 	lowercase_      (			unittest.TestCase     ):






      '''simple docstring'''




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




       """simple docstring"""


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

       return MarkupLMProcessor(lowercase_				,      lowercase_						)







      @slow
      def    __lowerCAmelCase      (   self   :		Union[str, Any]						)					->Optional[int]:




       """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						)						)










def 		_a					(   a				:list				)							->    list:
 for i, _ in enumerate(a				):
  if (i % 2 == 1) == (nums[i - 1] > nums[i]):
   a						,  a							=   nums[i], nums[i - 1]

 return nums


if __name__ == "__main__":
     print("Enter the array elements:")
     UpperCAmelCase__            =	list(map(int, input().split()))
     print("The unsorted array is:")
     print(array)
     print("Array after Wiggle sort:")
     print(wiggle_sort(array))


