






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

   def __init__(					self ,				snake_case_      )		->       int:
         UpperCamelCase__         =    parent







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
         return {}







def   lowerCAmelCase_( )					->	int:
      """simple docstring"""

      UpperCamelCase__         =    '<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>'

      UpperCamelCase__         =    '\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    __lowerCamelCase    (  __a							,	unittest.TestCase  ):
   a      :				Optional[int] 						=MarkupLMFeatureExtractor if is_bsa_available() else None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
         UpperCamelCase__         =    MarkupLMFeatureExtractionTester(self      )

   @property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
         return self.feature_extract_tester.prepare_feat_extract_dict()







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
         UpperCamelCase__         =    self.feature_extraction_class()

         # Test not batched input
         UpperCamelCase__         =    get_html_strings()[0]
         UpperCamelCase__         =    feature_extractor(lowerCAmelCase_      )

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

         # Test batched
         UpperCamelCase__         =    get_html_strings()
         UpperCamelCase__         =    feature_extractor(lowerCAmelCase_      )

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

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

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












"""simple docstring"""





from argparse import ArgumentParser

from . import BaseTransformersCLICommand







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	Dict:
    """simple docstring"""

    return DownloadCommand(args.model ,	args.cache_dir ,	args.force ,	args.trust_remote_code					)





class    __lowerCamelCase    (  _a  ):

   @staticmethod
   def 						SCREAMING_SNAKE_CASE__ (					snake_case_      )		->       Union[str, Any]:
       UpperCamelCase__         =    parser.add_parser('download'      )
       download_parser.add_argument(
           '--cache-dir' ,				type=snake_case_ ,				default=snake_case_ ,				help='Path to location to store the models'      )
       download_parser.add_argument(
           '--force' ,				action='store_true' ,				help='Force the model to be download even if already in cache-dir'      )
       download_parser.add_argument(
           '--trust-remote-code' ,				action='store_true' ,				help='Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine' ,				)
       download_parser.add_argument('model' ,				type=snake_case_ ,				help='Name of the model to download'      )
       download_parser.set_defaults(func=snake_case_      )

   def __init__(					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       str:
       UpperCamelCase__         =    model
       UpperCamelCase__         =    cache
       UpperCamelCase__         =    force
       UpperCamelCase__         =    trust_remote_code







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       from ..models.auto import AutoModel, AutoTokenizer

       AutoModel.from_pretrained(
           self._model ,				cache_dir=self._cache ,				force_download=self._force ,				trust_remote_code=self._trust_remote_code      )
       AutoTokenizer.from_pretrained(
           self._model ,				cache_dir=self._cache ,				force_download=self._force ,				trust_remote_code=self._trust_remote_code      )




