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




      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.0_2      ,				lowercase_=3      ,				lowercase_=None      ,				lowercase_=2_0      ,				lowercase_=3_0      ,				lowercase_=2      ,				lowercase_=2      ,				lowercase_=1_0      ,				)  ->    Optional[Any]:
          UpperCAmelCase  	=    parent
          UpperCAmelCase  	=    batch_size
          UpperCAmelCase  	=    seq_length
          UpperCAmelCase  	=    is_training
          UpperCAmelCase  	=    use_input_mask
          UpperCAmelCase  	=    use_token_type_ids
          UpperCAmelCase  	=    use_labels
          UpperCAmelCase  	=    vocab_size
          UpperCAmelCase  	=    hidden_size
          UpperCAmelCase  	=    num_hidden_layers
          UpperCAmelCase  	=    num_attention_heads
          UpperCAmelCase  	=    intermediate_size
          UpperCAmelCase  	=    hidden_act
          UpperCAmelCase  	=    hidden_dropout_prob
          UpperCAmelCase  	=    attention_probs_dropout_prob
          UpperCAmelCase  	=    max_position_embeddings
          UpperCAmelCase  	=    type_vocab_size
          UpperCAmelCase  	=    type_sequence_label_size
          UpperCAmelCase  	=    initializer_range
          UpperCAmelCase  	=    num_labels
          UpperCAmelCase  	=    scope
          UpperCAmelCase  	=    max_xpath_tag_unit_embeddings
          UpperCAmelCase  	=    max_xpath_subs_unit_embeddings
          UpperCAmelCase  	=    tag_pad_id
          UpperCAmelCase  	=    subs_pad_id
          UpperCAmelCase  	=    max_depth




      def 			a_					(							self							)  ->    Optional[int]:
          UpperCAmelCase  	=    ids_tensor([self.batch_size, self.seq_length]      ,				self.vocab_size							)

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

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

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

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

          UpperCAmelCase  	=    None
          UpperCAmelCase  	=    None
          if self.use_labels:
              UpperCAmelCase  	=    ids_tensor([self.batch_size]      ,				self.type_sequence_label_size							)
              UpperCAmelCase  	=    ids_tensor([self.batch_size, self.seq_length]      ,				self.num_labels							)

          UpperCAmelCase  	=    self.get_config()

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




      def 			a_					(							self							)  ->    Tuple:
          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 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				)  ->    int:
          UpperCAmelCase  	=    MarkupLMModel(config=lowercase_							)
          model.to(lowercase_							)
          model.eval()
          print('Configs:'      ,				model.config.tag_pad_id      ,				model.config.subs_pad_id							)
          UpperCAmelCase  	=    model(lowercase_      ,				attention_mask=lowercase_      ,				token_type_ids=lowercase_							)
          UpperCAmelCase  	=    model(lowercase_      ,				token_type_ids=lowercase_							)
          UpperCAmelCase  	=    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 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				)  ->    Dict:
          UpperCAmelCase  	=    self.num_labels
          UpperCAmelCase  	=    MarkupLMForSequenceClassification(lowercase_							)
          model.to(lowercase_							)
          model.eval()
          UpperCAmelCase  	=    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 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				)  ->    str:
          UpperCAmelCase  	=    self.num_labels
          UpperCAmelCase  	=    MarkupLMForTokenClassification(config=lowercase_							)
          model.to(lowercase_							)
          model.eval()
          UpperCAmelCase  	=    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 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				)  ->    List[Any]:
          UpperCAmelCase  	=    MarkupLMForQuestionAnswering(config=lowercase_							)
          model.to(lowercase_							)
          model.eval()
          UpperCAmelCase  	=    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 			a_					(							self							)  ->    List[str]:
          UpperCAmelCase  	=    self.prepare_config_and_inputs()
          (
              (
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							
          )  	=    config_and_inputs
          UpperCAmelCase  	=    {
              '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    _UpperCAmelCase							(						SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_   ,	unittest.TestCase							):
      __SCREAMING_SNAKE_CASE      :							Any												=		(
          (
              MarkupLMModel,
              MarkupLMForSequenceClassification,
              MarkupLMForTokenClassification,
              MarkupLMForQuestionAnswering,
          )
          if is_torch_available()
          else None
      )
      __SCREAMING_SNAKE_CASE      :							Tuple												=		(
          {
              "feature-extraction": MarkupLMModel,
              "question-answering": MarkupLMForQuestionAnswering,
              "text-classification": MarkupLMForSequenceClassification,
              "token-classification": MarkupLMForTokenClassification,
              "zero-shot": MarkupLMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )




      def 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_							)  ->    Optional[int]:
          # ValueError: Nodes must be of type `List[str]` (single pretokenized example), or `List[List[str]]`
          # (batch of pretokenized examples).
          return True




      def 			a_					(							self							)  ->    Union[str, Any]:
          UpperCAmelCase  	=    MarkupLMModelTester(self							)
          UpperCAmelCase  	=    ConfigTester(self      ,				config_class=lowercase_      ,				hidden_size=3_7							)




      def 			a_					(							self							)  ->    Dict:
          self.config_tester.run_common_tests()




      def 			a_					(							self							)  ->    Union[str, Any]:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_							)




      def 			a_					(							self							)  ->    Dict:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*lowercase_							)




      def 			a_					(							self							)  ->    Union[str, Any]:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*lowercase_							)




      def 			a_					(							self							)  ->    str:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*lowercase_							)




def 			lowercase__  (    )       ->					Optional[int]:






    """simple docstring"""




    UpperCAmelCase  	=    '\n    <!DOCTYPE html>\n    <html>\n    <head>\n    <title>Page Title</title>\n    </head>\n    <body>\n\n    <h1>This is a Heading</h1>\n    <p>This is a paragraph.</p>\n\n    </body>\n    </html>\n    '

    return html_string







@require_torch
class    _UpperCAmelCase							(						unittest.TestCase							):




      @cached_property
      def 			a_					(							self							)  ->    Any:
          # TODO use from_pretrained here
          UpperCAmelCase  	=    MarkupLMFeatureExtractor()
          UpperCAmelCase  	=    MarkupLMTokenizer.from_pretrained('microsoft/markuplm-base'							)

          return MarkupLMProcessor(lowercase_      ,				lowercase_							)




      @slow
      def 			a_					(							self							)  ->    Optional[int]:
          UpperCAmelCase  	=    MarkupLMModel.from_pretrained('microsoft/markuplm-base'							).to(lowercase_							)

          UpperCAmelCase  	=    self.default_processor

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

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

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

          UpperCAmelCase  	=    torch.tensor(
              [[0.0_6_7_5, -0.0_0_5_2, 0.5_0_0_1], [-0.2_2_8_1, 0.0_8_0_2, 0.2_1_9_2], [-0.0_5_8_3, -0.3_3_1_1, 0.1_1_8_5]]							).to(lowercase_							)

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





"""simple docstring"""

import doctest

import projectq
from projectq.ops import H, Measure




def 			lowercase__  (    lowerCAmelCase :    projectq.cengines._main.MainEngine       )       ->					int:






    """simple docstring"""




    UpperCAmelCase  	=    quantum_engine.allocate_qubit()
    H | qubit
    Measure | qubit
    return int(lowerCAmelCase       )


if __name__ == "__main__":
   doctest.testmod()

   # initialises a new quantum backend
   SCREAMING_SNAKE_CASE_			    =  projectq.MainEngine()

   # Generate a list of 10 random numbers
   SCREAMING_SNAKE_CASE_			    =  [get_random_number(quantum_engine) for _ in range(10)]

   # Flushes the quantum engine from memory
   quantum_engine.flush()

   print('''Random numbers''', random_numbers_list)



