
import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class 		UpperCAmelCase_	(_a  , unittest.TestCase						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ElectraTokenizer
 UpperCamelCase_						:     Tuple				   =    ElectraTokenizerFast
 UpperCamelCase_						:     int				   =    True
 UpperCamelCase_						:     Optional[int]				   =    True
 UpperCamelCase_						:     int				   =    filter_non_english




 def   a      ( self       : int )->					Union[str, Any]:



      """simple docstring"""

      super().setUp()

      UpperCAmelCase_						:    Union[str, Any]    					=  [
          "[UNK]",
          "[CLS]",
          "[SEP]",
          "[PAD]",
          "[MASK]",
          "want",
          "##want",
          "##ed",
          "wa",
          "un",
          "runn",
          "##ing",
          ",",
          "low",
          "lowest",
      ]
      UpperCAmelCase_						:    Optional[Any]    					=  os.path.join(self.tmpdirname     ,   VOCAB_FILES_NAMES["""vocab_file"""] )
      with open(self.vocab_file     ,   """w"""     ,   encoding="""utf-8""" ) as vocab_writer:
           vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) )




 def   a      ( self       : int     ,   a_       : Union[str, Any] )->					str:



      """simple docstring"""

      UpperCAmelCase_						:    Union[str, Any]    					=  "UNwant\u00E9d,running"
      UpperCAmelCase_						:    int    					=  "unwanted, running"
      return input_text, output_text




 def   a      ( self       : Optional[int] )->					Any:



      """simple docstring"""

      UpperCAmelCase_						:    Any    					=  self.tokenizer_class(self.vocab_file )

      UpperCAmelCase_						:    Optional[int]    					=  tokenizer.tokenize("""UNwant\u00E9d,running""" )
      self.assertListEqual(lowerCamelCase__     ,   ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] )
      self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ )     ,   [9, 6, 7, 12, 10, 11] )




 def   a      ( self       : Optional[Any] )->					Optional[int]:



      """simple docstring"""

      if not self.test_rust_tokenizer:
           return

      UpperCAmelCase_						:    int    					=  self.get_tokenizer()
      UpperCAmelCase_						:    List[str]    					=  self.get_rust_tokenizer()

      UpperCAmelCase_						:    Optional[int]    					=  "UNwant\u00E9d,running"

      UpperCAmelCase_						:    Any    					=  tokenizer.tokenize(lowerCamelCase__ )
      UpperCAmelCase_						:    Dict    					=  rust_tokenizer.tokenize(lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

      UpperCAmelCase_						:    Tuple    					=  tokenizer.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
      UpperCAmelCase_						:    List[str]    					=  rust_tokenizer.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

      UpperCAmelCase_						:    Optional[Any]    					=  self.get_rust_tokenizer()
      UpperCAmelCase_						:    List[Any]    					=  tokenizer.encode(lowerCamelCase__ )
      UpperCAmelCase_						:    Dict    					=  rust_tokenizer.encode(lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

      # With lower casing
      UpperCAmelCase_						:    int    					=  self.get_tokenizer(do_lower_case=lowerCamelCase__ )
      UpperCAmelCase_						:    Optional[Any]    					=  self.get_rust_tokenizer(do_lower_case=lowerCamelCase__ )

      UpperCAmelCase_						:    Any    					=  "UNwant\u00E9d,running"

      UpperCAmelCase_						:    Optional[int]    					=  tokenizer.tokenize(lowerCamelCase__ )
      UpperCAmelCase_						:    int    					=  rust_tokenizer.tokenize(lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

      UpperCAmelCase_						:    Optional[Any]    					=  tokenizer.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
      UpperCAmelCase_						:    Any    					=  rust_tokenizer.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

      UpperCAmelCase_						:    Optional[Any]    					=  self.get_rust_tokenizer()
      UpperCAmelCase_						:    Tuple    					=  tokenizer.encode(lowerCamelCase__ )
      UpperCAmelCase_						:    List[Any]    					=  rust_tokenizer.encode(lowerCamelCase__ )
      self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )




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



      """simple docstring"""

      UpperCAmelCase_						:    Tuple    					=  BasicTokenizer()

      self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" )     ,   ["""ah""", """\u535A""", """\u63A8""", """zz"""] )




 def   a      ( self       : List[Any] )->					Dict:



      """simple docstring"""

      UpperCAmelCase_						:    List[str]    					=  BasicTokenizer(do_lower_case=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """ )     ,   ["""hello""", """!""", """how""", """are""", """you""", """?"""] )
      self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )     ,   ["""hello"""] )




 def   a      ( self       : Union[str, Any] )->					Tuple:



      """simple docstring"""

      UpperCAmelCase_						:    int    					=  BasicTokenizer(do_lower_case=lowerCamelCase__     ,   strip_accents=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )     ,   ["""hällo""", """!""", """how""", """are""", """you""", """?"""] )
      self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )     ,   ["""h\u00E9llo"""] )




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



      """simple docstring"""

      UpperCAmelCase_						:    Dict    					=  BasicTokenizer(do_lower_case=lowerCamelCase__     ,   strip_accents=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )     ,   ["""hallo""", """!""", """how""", """are""", """you""", """?"""] )
      self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )     ,   ["""hello"""] )




 def   a      ( self       : int )->					List[str]:



      """simple docstring"""

      UpperCAmelCase_						:    Tuple    					=  BasicTokenizer(do_lower_case=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )     ,   ["""hallo""", """!""", """how""", """are""", """you""", """?"""] )
      self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )     ,   ["""hello"""] )




 def   a      ( self       : str )->					int:



      """simple docstring"""

      UpperCAmelCase_						:    int    					=  BasicTokenizer(do_lower_case=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """ )     ,   ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )




 def   a      ( self       : Dict )->					int:



      """simple docstring"""

      UpperCAmelCase_						:    Dict    					=  BasicTokenizer(do_lower_case=lowerCamelCase__     ,   strip_accents=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )     ,   ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )




 def   a      ( self       : Optional[int] )->					Dict:



      """simple docstring"""

      UpperCAmelCase_						:    List[Any]    					=  BasicTokenizer(do_lower_case=lowerCamelCase__     ,   strip_accents=lowerCamelCase__ )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )     ,   ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )




 def   a      ( self       : Optional[int] )->					List[str]:



      """simple docstring"""

      UpperCAmelCase_						:    Dict    					=  BasicTokenizer(do_lower_case=lowerCamelCase__     ,   never_split=["""[UNK]"""] )

      self.assertListEqual(
          tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]""" )     ,   ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] )




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



      """simple docstring"""

      UpperCAmelCase_						:    List[Any]    					=  ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

      UpperCAmelCase_						:    int    					=  {}
      for i, token in enumerate(lowerCamelCase__ ):
           UpperCAmelCase_						:    Optional[int]    					=  i
      UpperCAmelCase_						:    Any    					=  WordpieceTokenizer(vocab=lowerCamelCase__     ,   unk_token="""[UNK]""" )

      self.assertListEqual(tokenizer.tokenize("""""" )     ,   [] )

      self.assertListEqual(tokenizer.tokenize("""unwanted running""" )     ,   ["""un""", """##want""", """##ed""", """runn""", """##ing"""] )

      self.assertListEqual(tokenizer.tokenize("""unwantedX running""" )     ,   ["""[UNK]""", """runn""", """##ing"""] )




 def   a      ( self       : List[Any] )->					Optional[Any]:



      """simple docstring"""

      self.assertTrue(_is_whitespace(""" """ ) )
      self.assertTrue(_is_whitespace("""\t""" ) )
      self.assertTrue(_is_whitespace("""\r""" ) )
      self.assertTrue(_is_whitespace("""\n""" ) )
      self.assertTrue(_is_whitespace("""\u00A0""" ) )

      self.assertFalse(_is_whitespace("""A""" ) )
      self.assertFalse(_is_whitespace("""-""" ) )




 def   a      ( self       : Any )->					Tuple:



      """simple docstring"""

      self.assertTrue(_is_control("""\u0005""" ) )

      self.assertFalse(_is_control("""A""" ) )
      self.assertFalse(_is_control(""" """ ) )
      self.assertFalse(_is_control("""\t""" ) )
      self.assertFalse(_is_control("""\r""" ) )




 def   a      ( self       : Dict )->					Union[str, Any]:



      """simple docstring"""

      self.assertTrue(_is_punctuation("""-""" ) )
      self.assertTrue(_is_punctuation("""$""" ) )
      self.assertTrue(_is_punctuation("""`""" ) )
      self.assertTrue(_is_punctuation(""".""" ) )

      self.assertFalse(_is_punctuation("""A""" ) )
      self.assertFalse(_is_punctuation(""" """ ) )




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



      """simple docstring"""

      UpperCAmelCase_						:    List[str]    					=  self.get_tokenizer()
      UpperCAmelCase_						:    List[Any]    					=  self.get_rust_tokenizer()

      # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
      self.assertListEqual([tokenizer.tokenize(lowerCamelCase__ ) for t in ["""Test""", """\xad""", """test"""]]     ,   [["""[UNK]"""], [], ["""[UNK]"""]] )

      self.assertListEqual(
          [rust_tokenizer.tokenize(lowerCamelCase__ ) for t in ["""Test""", """\xad""", """test"""]]     ,   [["""[UNK]"""], [], ["""[UNK]"""]] )




 @slow
 def   a      ( self       : Optional[Any] )->					List[Any]:



      """simple docstring"""

      UpperCAmelCase_						:    List[str]    					=  self.tokenizer_class.from_pretrained("""google/electra-base-discriminator""" )

      UpperCAmelCase_						:    Optional[Any]    					=  tokenizer.encode("""sequence builders"""     ,   add_special_tokens=lowerCamelCase__ )
      UpperCAmelCase_						:    Optional[Any]    					=  tokenizer.encode("""multi-sequence build"""     ,   add_special_tokens=lowerCamelCase__ )

      UpperCAmelCase_						:    Optional[int]    					=  tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ )
      UpperCAmelCase_						:    Optional[Any]    					=  tokenizer.build_inputs_with_special_tokens(lowerCamelCase__     ,   lowerCamelCase__ )

      assert encoded_sentence == [1_01] + text + [1_02]
      assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]




 def   a      ( self       : str )->					Optional[int]:



      """simple docstring"""

      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
                UpperCAmelCase_						:    Optional[Any]    					=  self.rust_tokenizer_class.from_pretrained(lowerCamelCase__     ,   **lowerCamelCase__ )

                UpperCAmelCase_						:    List[Any]    					=  f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
                UpperCAmelCase_						:    List[str]    					=  tokenizer_r.encode_plus(
                    lowerCamelCase__     ,   return_attention_mask=lowerCamelCase__     ,   return_token_type_ids=lowerCamelCase__     ,   return_offsets_mapping=lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__     ,   )

                UpperCAmelCase_						:    Optional[int]    					=  tokenizer_r.do_lower_case if hasattr(lowerCamelCase__     ,   """do_lower_case""" ) else False
                UpperCAmelCase_						:    Tuple    					=  (
                    [
                        ((0, 0), tokenizer_r.cls_token),
                        ((0, 1), "A"),
                        ((1, 2), ","),
                        ((3, 5), "na"),
                        ((5, 6), "##ï"),
                        ((6, 8), "##ve"),
                        ((9, 15), tokenizer_r.mask_token),
                        ((16, 21), "Allen"),
                        ((21, 23), "##NL"),
                        ((23, 24), "##P"),
                        ((25, 33), "sentence"),
                        ((33, 34), "."),
                        ((0, 0), tokenizer_r.sep_token),
                    ]
                    if not do_lower_case
                    else [
                        ((0, 0), tokenizer_r.cls_token),
                        ((0, 1), "a"),
                        ((1, 2), ","),
                        ((3, 8), "naive"),
                        ((9, 15), tokenizer_r.mask_token),
                        ((16, 21), "allen"),
                        ((21, 23), "##nl"),
                        ((23, 24), "##p"),
                        ((25, 33), "sentence"),
                        ((33, 34), "."),
                        ((0, 0), tokenizer_r.sep_token),
                    ]
                )

                self.assertEqual(
                    [e[1] for e in expected_results]     ,   tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""] ) )
                self.assertEqual([e[0] for e in expected_results]     ,   tokens["""offset_mapping"""] )






 def   a      ( self       : Dict )->					List[str]:



      """simple docstring"""

      UpperCAmelCase_						:    Union[str, Any]    					=  ["的", "人", "有"]
      UpperCAmelCase_						:    Tuple    					=  "".join(lowerCamelCase__ )
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
                UpperCAmelCase_						:    Dict    					=  True
                UpperCAmelCase_						:    List[str]    					=  self.tokenizer_class.from_pretrained(lowerCamelCase__     ,   **lowerCamelCase__ )
                UpperCAmelCase_						:    Optional[int]    					=  self.rust_tokenizer_class.from_pretrained(lowerCamelCase__     ,   **lowerCamelCase__ )

                UpperCAmelCase_						:    int    					=  tokenizer_p.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
                UpperCAmelCase_						:    str    					=  tokenizer_r.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )

                UpperCAmelCase_						:    Optional[Any]    					=  tokenizer_r.convert_ids_to_tokens(lowerCamelCase__ )
                UpperCAmelCase_						:    str    					=  tokenizer_p.convert_ids_to_tokens(lowerCamelCase__ )

                # it is expected that each Chinese character is not preceded by "##"
                self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )
                self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )

                UpperCAmelCase_						:    Any    					=  False
                UpperCAmelCase_						:    Union[str, Any]    					=  self.rust_tokenizer_class.from_pretrained(lowerCamelCase__     ,   **lowerCamelCase__ )
                UpperCAmelCase_						:    Dict    					=  self.tokenizer_class.from_pretrained(lowerCamelCase__     ,   **lowerCamelCase__ )

                UpperCAmelCase_						:    Tuple    					=  tokenizer_r.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )
                UpperCAmelCase_						:    List[str]    					=  tokenizer_p.encode(lowerCamelCase__     ,   add_special_tokens=lowerCamelCase__ )

                UpperCAmelCase_						:    Any    					=  tokenizer_r.convert_ids_to_tokens(lowerCamelCase__ )
                UpperCAmelCase_						:    Dict    					=  tokenizer_p.convert_ids_to_tokens(lowerCamelCase__ )

                # it is expected that only the first Chinese character is not preceded by "##".
                UpperCAmelCase_						:    Union[str, Any]    					=  [
                    f'''##{token}''' if idx != 0 else token for idx, token in enumerate(lowerCamelCase__ )
                ]
                self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )
                self.assertListEqual(lowerCamelCase__     ,   lowerCamelCase__ )



"""simple docstring"""







def 			A_			(					lowercase = 99_8001      )     ->							int:


     """simple docstring"""







     for number in range(n - 1						, 9999						, -1      ):
          UpperCAmelCase_						:    Union[str, Any]    					=  str(lowercase      )

          # checks whether 'str_number' is a palindrome.
          if str_number == str_number[::-1]:
               UpperCAmelCase_						:    List[str]    					=  999

               # if 'number' is a product of two 3-digit numbers
               # then number is the answer otherwise fetch next number.
               while divisor != 99:
                    if (number % divisor == 0) and (len(str(number // divisor      )      ) == 3.0):
                         return number
                    divisor -= 1
     raise ValueError("""That number is larger than our acceptable range."""      )


if __name__ == "__main__":
       print(f"""{solution() = }""")

