



'''simple docstring'''






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







    def __init__(      self :  Tuple						,			__snake_case :  Optional[int]	):
      a						:					Union[str, Any]        =     parent







    def 			lowercase_       (      self :  Union[str, Any]	):
      return {}
def       lowerCamelCase__       (						):
  a						:					List[Any]        =     '<HTML>\n\n    <HEAD>\n    <TITLE>sample document</TITLE>\n    </HEAD>\n\n    <BODY BGCOLOR="FFFFFF">\n    <HR>\n    <a href="http://google.com">Goog</a>\n    <H1>This is one header</H1>\n    <H2>This is a another Header</H2>\n    <P>Travel from\n        <P>\n        <B>SFO to JFK</B>\n        <BR>\n        <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>\n        <HR>\n        <div style="color:#0000FF">\n            <h3>Traveler <b> name </b> is\n            <p> John Doe </p>\n        </div>'

  a						:					Optional[int]        =     '\n    <!DOCTYPE html>\n    <html>\n    <body>\n\n    <h1>My First Heading</h1>\n    <p>My first paragraph.</p>\n\n    </body>\n    </html>\n    '

  return [html_string_a, html_string_a]

@require_bsa
class 							a__(					_a		, unittest.TestCase	):
    lowercase__ =    MarkupLMFeatureExtractor if is_bsa_available() else None







    def 			lowercase_       (      self :  Any	):
      a						:					List[str]        =     MarkupLMFeatureExtractionTester(self	)







    @property
    def 			lowercase_       (      self :  Dict	):
      return self.feature_extract_tester.prepare_feat_extract_dict()







    def 			lowercase_       (      self :  List[Any]	):
      a						:					Any        =     self.feature_extraction_class()

      # Test not batched input
      a						:					Union[str, Any]        =     get_html_strings()[0]
      a						:					Union[str, Any]        =     feature_extractor(UpperCamelCase__	)

      # fmt: off
      a						:					List[str]        =     [['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']]
      a						:					Optional[Any]        =     [['/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						,			UpperCamelCase__	)
      self.assertEqual(encoding.xpaths						,			UpperCamelCase__	)

      # Test batched
      a						:					str        =     get_html_strings()
      a						:					str        =     feature_extractor(UpperCamelCase__	)

      # fmt: off
      a						:					Union[str, Any]        =     expected_nodes + [['My First Heading', 'My first paragraph.']]
      a						:					Optional[Any]        =     expected_xpaths + [['/html/body/h1', '/html/body/p']]

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

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




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


_lowerCamelCase	:       List[Any]      	=	{
    "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"],
    "tokenization_m2m_100": ["M2M100Tokenizer"],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _lowerCamelCase	:       int      	=	[
       "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST",
       "M2M100ForConditionalGeneration",
       "M2M100Model",
       "M2M100PreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
   from .tokenization_mam_aaa import MaMaaaTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mam_aaa import (
          M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
          MaMaaaForConditionalGeneration,
          MaMaaaModel,
          MaMaaaPreTrainedModel,
      )


else:
   import sys

   _lowerCamelCase	:       Optional[int]      	=	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

