





'''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		: str     ,				lowercase		: Union[str, Any]						):





        """simple docstring"""




        lowercase_      :str         =			parent







     def 							lowercase__				(			self		: Any						):





        """simple docstring"""




        return {}







def 							UpperCAmelCase_  (						):
   lowercase_      :Optional[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>"

   lowercase_      :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_       (    _lowerCAmelCase     ,						unittest.TestCase							):
     __A								=      MarkupLMFeatureExtractor if is_bsa_available() else None





     def 							lowercase__				(			self		: Union[str, Any]						):





        """simple docstring"""




        lowercase_      :Optional[Any]         =			MarkupLMFeatureExtractionTester(self						)





     @property
     def 							lowercase__				(			self		: List[str]						):





        """simple docstring"""




        return self.feature_extract_tester.prepare_feat_extract_dict()







     def 							lowercase__				(			self		: Tuple						):





        """simple docstring"""




        lowercase_      :List[str]         =			self.feature_extraction_class()

        # Test not batched input
        lowercase_      :int         =			get_html_strings()[0]
        lowercase_      :Any         =			feature_extractor(lowercase						)

        # fmt: off
        lowercase_      :Union[str, Any]         =			[["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_      :Dict         =			[["/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_      :Any         =			get_html_strings()
        lowercase_      :Tuple         =			feature_extractor(lowercase						)

        # fmt: off
        lowercase_      :Union[str, Any]         =			expected_nodes + [["My First Heading", "My first paragraph."]]
        lowercase_      :List[str]         =			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						)









'''simple docstring'''


import numpy as np
def 							UpperCAmelCase_  (						__lowerCamelCase : str     ,__lowerCamelCase : Optional[Any]     ,__lowerCamelCase : int     ,__lowerCamelCase : List[str]     ,__lowerCamelCase : List[Any]			):
   lowercase_      :Dict         =			int(np.ceil((x_end - xa) / h			)			)
   lowercase_      :Optional[int]         =			np.zeros((n + 1,)			)
   lowercase_      :Tuple         =			ya
   lowercase_      :List[str]         =			xa

   for k in range(__lowerCamelCase			):
      lowercase_      :Any         =			f(__lowerCamelCase     ,y[k]			)
      lowercase_      :Optional[Any]         =			f(x + 0.5 * h     ,y[k] + 0.5 * h * ka			)
      lowercase_      :Optional[Any]         =			f(x + 0.5 * h     ,y[k] + 0.5 * h * ka			)
      lowercase_      :Any         =			f(x + h     ,y[k] + h * ka			)
      lowercase_      :Tuple         =			y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
      x += h

   return y


if __name__ == "__main__":
 import doctest

 doctest.testmod()


