


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							):
					'''simple docstring'''






					def __init__(self   :						Optional[Any]				, _UpperCAmelCase   :						List[Any]		)						->       Dict:




							"""simple docstring"""


							lowercase__					      =		parent


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




							"""simple docstring"""


							return {}






def 			UpperCamelCase (     )       ->  str:
		"""simple docstring"""




		lowercase__					      =		"""<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>"""

		lowercase__					      =		"""
    <!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 							A   (	__A			,  unittest.TestCase							):
					'''simple docstring'''






					A__      =			MarkupLMFeatureExtractor if is_bsa_available() else None

					def   lowerCamelCase__					(self   :						Tuple		)						->       Optional[Any]:




							"""simple docstring"""


							lowercase__					      =		MarkupLMFeatureExtractionTester(self		)

					@property
					def   lowerCamelCase__					(self   :						List[Any]		)						->       Tuple:




							"""simple docstring"""


							return self.feature_extract_tester.prepare_feat_extract_dict()


					def   lowerCamelCase__					(self   :						Tuple		)						->       Optional[Any]:




							"""simple docstring"""


							lowercase__					      =		self.feature_extraction_class()

							# Test not batched input
							lowercase__					      =		get_html_strings()[0]
							lowercase__					      =		feature_extractor(__lowercase		)

							# fmt: off
							lowercase__					      =		[["""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"""]]
							lowercase__					      =		[["""/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				, __lowercase		)
							self.assertEqual(encoding.xpaths				, __lowercase		)

							# Test batched
							lowercase__					      =		get_html_strings()
							lowercase__					      =		feature_extractor(__lowercase		)

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

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

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






from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A	:		Optional[Any]    =       logging.get_logger(__name__)

A	:		Tuple    =       {
    'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json',
    'YituTech/conv-bert-medium-small': (
        'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json'
    ),
    'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json',
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}



class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					A__      =			'''convbert'''

					def __init__(self   :						str				, _UpperCAmelCase   :						Union[str, Any]=3_0522				, _UpperCAmelCase   :						Dict=768				, _UpperCAmelCase   :						Optional[int]=12				, _UpperCAmelCase   :						List[str]=12				, _UpperCAmelCase   :						str=3072				, _UpperCAmelCase   :						Tuple="gelu"				, _UpperCAmelCase   :						Optional[int]=0.1				, _UpperCAmelCase   :						int=0.1				, _UpperCAmelCase   :						str=512				, _UpperCAmelCase   :						Dict=2				, _UpperCAmelCase   :						int=0.02				, _UpperCAmelCase   :						Tuple=1E-1_2				, _UpperCAmelCase   :						Dict=1				, _UpperCAmelCase   :						Optional[Any]=0				, _UpperCAmelCase   :						List[str]=2				, _UpperCAmelCase   :						str=768				, _UpperCAmelCase   :						List[Any]=2				, _UpperCAmelCase   :						Optional[Any]=9				, _UpperCAmelCase   :						List[Any]=1				, _UpperCAmelCase   :						Union[str, Any]=None				, **_UpperCAmelCase   :						List[Any]				, )						->       List[str]:




							"""simple docstring"""


							super().__init__(
							    pad_token_id=_UpperCAmelCase				, bos_token_id=_UpperCAmelCase				, eos_token_id=_UpperCAmelCase				, **_UpperCAmelCase				, )

							lowercase__					      =		vocab_size
							lowercase__					      =		hidden_size
							lowercase__					      =		num_hidden_layers
							lowercase__					      =		num_attention_heads
							lowercase__					      =		intermediate_size
							lowercase__					      =		hidden_act
							lowercase__					      =		hidden_dropout_prob
							lowercase__					      =		attention_probs_dropout_prob
							lowercase__					      =		max_position_embeddings
							lowercase__					      =		type_vocab_size
							lowercase__					      =		initializer_range
							lowercase__					      =		layer_norm_eps
							lowercase__					      =		embedding_size
							lowercase__					      =		head_ratio
							lowercase__					      =		conv_kernel_size
							lowercase__					      =		num_groups
							lowercase__					      =		classifier_dropout






class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






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




							"""simple docstring"""


							if self.task == "multiple-choice":
									lowercase__					      =		{0: """batch""", 1: """choice""", 2: """sequence"""}
							else:
									lowercase__					      =		{0: """batch""", 1: """sequence"""}
							return OrderedDict(
							    [
							        ("""input_ids""", dynamic_axis),
							        ("""attention_mask""", dynamic_axis),
							        ("""token_type_ids""", dynamic_axis),
							    ]		)

