

import unittest

from transformers.testing_utils import require_bsa
from transformers.utils import is_bsa_available

from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin


if is_bsa_available():
       from transformers import MarkupLMFeatureExtractor






class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  def __init__(							self		:	Any			,     __lowerCamelCase		:	Dict      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					parent







  def    lowercase_	(							self		:	Any      )	->							List[str]:
       return {}



def        UpperCAmelCase_     (		):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					'''<HTML>

    <HEAD>
    <TITLE>sample document</TITLE>
    </HEAD>

    <BODY BGCOLOR="FFFFFF">
    <HR>
    <a href="http://google.com">Goog</a>
    <H1>This is one header</H1>
    <H2>This is a another Header</H2>
    <P>Travel from
        <P>
        <B>SFO to JFK</B>
        <BR>
        <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>
        <HR>
        <div style="color:#0000FF">
            <h3>Traveler <b> name </b> is
            <p> John Doe </p>
        </div>'''

     SCREAMING_SNAKE_CASE__					=					'''
    <!DOCTYPE html>
    <html>
    <body>

    <h1>My First Heading</h1>
    <p>My first paragraph.</p>

    </body>
    </html>
    '''

     return [html_string_a, html_string_a]







@require_bsa
class  UpperCAmelCase__	( __UpperCAmelCase		,  unittest.TestCase ):






  """simple docstring"""


  a     =      MarkupLMFeatureExtractor if is_bsa_available() else None






  def    lowercase_	(							self		:	Dict      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					MarkupLMFeatureExtractionTester(self      )






  @property
  def    lowercase_	(							self		:	List[Any]      )	->							Dict:
       return self.feature_extract_tester.prepare_feat_extract_dict()







  def    lowercase_	(							self		:	Optional[int]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.feature_extraction_class()

       # Test not batched input
       SCREAMING_SNAKE_CASE__					=					get_html_strings()[0]
       SCREAMING_SNAKE_CASE__					=					feature_extractor(__SCREAMING_SNAKE_CASE      )

       # fmt: off
       SCREAMING_SNAKE_CASE__					=					[['''sample document''', '''Goog''', '''This is one header''', '''This is a another Header''', '''Travel from''', '''SFO to JFK''', '''on May 2, 2015 at 2:00 pm. For details go to confirm.com''', '''Traveler''', '''name''', '''is''', '''John Doe''']]
       SCREAMING_SNAKE_CASE__					=					[['''/html/head/title''', '''/html/body/a''', '''/html/body/h1''', '''/html/body/h2''', '''/html/body/p''', '''/html/body/p/p/b[1]''', '''/html/body/p/p/b[2]/i''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/b''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/p''']]
       # fmt: on

       self.assertEqual(encoding.nodes			,     __SCREAMING_SNAKE_CASE      )
       self.assertEqual(encoding.xpaths			,     __SCREAMING_SNAKE_CASE      )

       # Test batched
       SCREAMING_SNAKE_CASE__					=					get_html_strings()
       SCREAMING_SNAKE_CASE__					=					feature_extractor(__SCREAMING_SNAKE_CASE      )

       # fmt: off
       SCREAMING_SNAKE_CASE__					=					expected_nodes + [['''My First Heading''', '''My first paragraph.''']]
       SCREAMING_SNAKE_CASE__					=					expected_xpaths + [['''/html/body/h1''', '''/html/body/p''']]

       self.assertEqual(len(encoding.nodes      )			,     2      )
       self.assertEqual(len(encoding.xpaths      )			,     2      )

       self.assertEqual(encoding.nodes			,     __SCREAMING_SNAKE_CASE      )
       self.assertEqual(encoding.xpaths			,     __SCREAMING_SNAKE_CASE      )





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE  :						List[Any]         =    {
    '''configuration_roberta''': ['''ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RobertaConfig''', '''RobertaOnnxConfig'''],
    '''tokenization_roberta''': ['''RobertaTokenizer'''],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _SCREAMING_SNAKE_CASE  :						Optional[int]         =    ['''RobertaTokenizerFast''']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _SCREAMING_SNAKE_CASE  :						Tuple         =    [
           '''ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''RobertaForCausalLM''',
           '''RobertaForMaskedLM''',
           '''RobertaForMultipleChoice''',
           '''RobertaForQuestionAnswering''',
           '''RobertaForSequenceClassification''',
           '''RobertaForTokenClassification''',
           '''RobertaModel''',
           '''RobertaPreTrainedModel''',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _SCREAMING_SNAKE_CASE  :						List[Any]         =    [
           '''TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''TFRobertaForCausalLM''',
           '''TFRobertaForMaskedLM''',
           '''TFRobertaForMultipleChoice''',
           '''TFRobertaForQuestionAnswering''',
           '''TFRobertaForSequenceClassification''',
           '''TFRobertaForTokenClassification''',
           '''TFRobertaMainLayer''',
           '''TFRobertaModel''',
           '''TFRobertaPreTrainedModel''',
       ]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _SCREAMING_SNAKE_CASE  :						Optional[Any]         =    [
           '''FlaxRobertaForCausalLM''',
           '''FlaxRobertaForMaskedLM''',
           '''FlaxRobertaForMultipleChoice''',
           '''FlaxRobertaForQuestionAnswering''',
           '''FlaxRobertaForSequenceClassification''',
           '''FlaxRobertaForTokenClassification''',
           '''FlaxRobertaModel''',
           '''FlaxRobertaPreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig, RobertaOnnxConfig
       from .tokenization_roberta import RobertaTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_roberta_fast import RobertaTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_roberta import (
                  ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  RobertaForCausalLM,
                  RobertaForMaskedLM,
                  RobertaForMultipleChoice,
                  RobertaForQuestionAnswering,
                  RobertaForSequenceClassification,
                  RobertaForTokenClassification,
                  RobertaModel,
                  RobertaPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_roberta import (
                  TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFRobertaForCausalLM,
                  TFRobertaForMaskedLM,
                  TFRobertaForMultipleChoice,
                  TFRobertaForQuestionAnswering,
                  TFRobertaForSequenceClassification,
                  TFRobertaForTokenClassification,
                  TFRobertaMainLayer,
                  TFRobertaModel,
                  TFRobertaPreTrainedModel,
              )

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_roberta import (
                  FlaxRobertaForCausalLM,
                  FlaxRobertaForMaskedLM,
                  FlaxRobertaForMultipleChoice,
                  FlaxRobertaForQuestionAnswering,
                  FlaxRobertaForSequenceClassification,
                  FlaxRobertaForTokenClassification,
                  FlaxRobertaModel,
                  FlaxRobertaPreTrainedModel,
              )

else:
       import sys

       _SCREAMING_SNAKE_CASE  :						str         =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


