

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     __magic_name__     (							_snake_case						,    unittest.TestCase     ):
 UpperCAmelCase				     =    ElectraTokenizer
 UpperCAmelCase				     =    ElectraTokenizerFast
 UpperCAmelCase				     =    True
 UpperCAmelCase				     =    True
 UpperCAmelCase				     =    filter_non_english


 def _UpperCamelCase						(    self		:			Any     )     ->   int:
   super().setUp()

   UpperCAmelCase          =	[
       "[UNK]",
       "[CLS]",
       "[SEP]",
       "[PAD]",
       "[MASK]",
       "want",
       "##want",
       "##ed",
       "wa",
       "un",
       "runn",
       "##ing",
       ",",
       "low",
       "lowest",
   ]
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			Optional[Any]      ,    lowerCAmelCase__		:			Any     )     ->   Tuple:
   UpperCAmelCase          =	"UNwant\u00E9d,running"
   UpperCAmelCase          =	"unwanted, running"
   return input_text, output_text


 def _UpperCamelCase						(    self		:			Tuple     )     ->   List[Any]:
   UpperCAmelCase          =	self.tokenizer_class(self.vocab_file     )

   UpperCAmelCase          =	tokenizer.tokenize("UNwant\u00E9d,running"     )
   self.assertListEqual(lowerCAmelCase__      ,    ["un", "##want", "##ed", ",", "runn", "##ing"]     )
   self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__     )      ,    [9, 6, 7, 1_2, 1_0, 1_1]     )


 def _UpperCamelCase						(    self		:			str     )     ->   Any:
   if not self.test_rust_tokenizer:
     return

   UpperCAmelCase          =	self.get_tokenizer()
   UpperCAmelCase          =	self.get_rust_tokenizer()

   UpperCAmelCase          =	"UNwant\u00E9d,running"

   UpperCAmelCase          =	tokenizer.tokenize(lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.tokenize(lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )

   UpperCAmelCase          =	tokenizer.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )

   UpperCAmelCase          =	self.get_rust_tokenizer()
   UpperCAmelCase          =	tokenizer.encode(lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.encode(lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )

   # With lower casing
   UpperCAmelCase          =	self.get_tokenizer(do_lower_case=lowerCAmelCase__     )
   UpperCAmelCase          =	self.get_rust_tokenizer(do_lower_case=lowerCAmelCase__     )

   UpperCAmelCase          =	"UNwant\u00E9d,running"

   UpperCAmelCase          =	tokenizer.tokenize(lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.tokenize(lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )

   UpperCAmelCase          =	tokenizer.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )

   UpperCAmelCase          =	self.get_rust_tokenizer()
   UpperCAmelCase          =	tokenizer.encode(lowerCAmelCase__     )
   UpperCAmelCase          =	rust_tokenizer.encode(lowerCAmelCase__     )
   self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )


 def _UpperCamelCase						(    self		:			Union[str, Any]     )     ->   Dict:
   UpperCAmelCase          =	BasicTokenizer()

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


 def _UpperCamelCase						(    self		:			Optional[int]     )     ->   Any:
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			Dict     )     ->   Dict:
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			List[str]     )     ->   List[Any]:
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			List[str]     )     ->   Dict:
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			Optional[int]     )     ->   List[str]:
   UpperCAmelCase          =	BasicTokenizer(do_lower_case=lowerCAmelCase__     )

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


 def _UpperCamelCase						(    self		:			Dict     )     ->   int:
   UpperCAmelCase          =	BasicTokenizer(do_lower_case=lowerCAmelCase__      ,    strip_accents=lowerCAmelCase__     )

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


 def _UpperCamelCase						(    self		:			Tuple     )     ->   List[str]:
   UpperCAmelCase          =	BasicTokenizer(do_lower_case=lowerCAmelCase__      ,    strip_accents=lowerCAmelCase__     )

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


 def _UpperCamelCase						(    self		:			Any     )     ->   Tuple:
   UpperCAmelCase          =	BasicTokenizer(do_lower_case=lowerCAmelCase__      ,    never_split=["[UNK]"]     )

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


 def _UpperCamelCase						(    self		:			Any     )     ->   Any:
   UpperCAmelCase          =	["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

   UpperCAmelCase          =	{}
   for i, token in enumerate(lowerCAmelCase__     ):
     UpperCAmelCase          =	i
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			List[str]     )     ->   Optional[Any]:
   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 _UpperCamelCase						(    self		:			Tuple     )     ->   int:
   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 _UpperCamelCase						(    self		:			Any     )     ->   List[str]:
   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 _UpperCamelCase						(    self		:			Dict     )     ->   str:
   UpperCAmelCase          =	self.get_tokenizer()
   UpperCAmelCase          =	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 _UpperCamelCase						(    self		:			Tuple     )     ->   Optional[Any]:
   UpperCAmelCase          =	self.tokenizer_class.from_pretrained("google/electra-base-discriminator"     )

   UpperCAmelCase          =	tokenizer.encode("sequence builders"      ,    add_special_tokens=lowerCAmelCase__     )
   UpperCAmelCase          =	tokenizer.encode("multi-sequence build"      ,    add_special_tokens=lowerCAmelCase__     )

   UpperCAmelCase          =	tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__     )
   UpperCAmelCase          =	tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__      ,    lowerCAmelCase__     )

   assert encoded_sentence == [1_0_1] + text + [1_0_2]
   assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]


 def _UpperCamelCase						(    self		:			List[str]     )     ->   Optional[Any]:
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"     ):
       UpperCAmelCase          =	self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__      ,    **lowerCAmelCase__     )

       UpperCAmelCase          =	f"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
       UpperCAmelCase          =	tokenizer_r.encode_plus(
           lowerCAmelCase__      ,    return_attention_mask=lowerCAmelCase__      ,    return_token_type_ids=lowerCAmelCase__      ,    return_offsets_mapping=lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__      ,    )

       UpperCAmelCase          =	tokenizer_r.do_lower_case if hasattr(lowerCAmelCase__      ,    "do_lower_case"     ) else False
       UpperCAmelCase          =	(
           [
               ((0, 0), tokenizer_r.cls_token),
               ((0, 1), "A"),
               ((1, 2), ","),
               ((3, 5), "na"),
               ((5, 6), "##ï"),
               ((6, 8), "##ve"),
               ((9, 1_5), tokenizer_r.mask_token),
               ((1_6, 2_1), "Allen"),
               ((2_1, 2_3), "##NL"),
               ((2_3, 2_4), "##P"),
               ((2_5, 3_3), "sentence"),
               ((3_3, 3_4), "."),
               ((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, 1_5), tokenizer_r.mask_token),
               ((1_6, 2_1), "allen"),
               ((2_1, 2_3), "##nl"),
               ((2_3, 2_4), "##p"),
               ((2_5, 3_3), "sentence"),
               ((3_3, 3_4), "."),
               ((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 _UpperCamelCase						(    self		:			List[str]     )     ->   Any:
   UpperCAmelCase          =	["的", "人", "有"]
   UpperCAmelCase          =	"".join(lowerCAmelCase__     )
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"     ):
       UpperCAmelCase          =	True
       UpperCAmelCase          =	self.tokenizer_class.from_pretrained(lowerCAmelCase__      ,    **lowerCAmelCase__     )
       UpperCAmelCase          =	self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__      ,    **lowerCAmelCase__     )

       UpperCAmelCase          =	tokenizer_p.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
       UpperCAmelCase          =	tokenizer_r.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )

       UpperCAmelCase          =	tokenizer_r.convert_ids_to_tokens(lowerCAmelCase__     )
       UpperCAmelCase          =	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          =	False
       UpperCAmelCase          =	self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__      ,    **lowerCAmelCase__     )
       UpperCAmelCase          =	self.tokenizer_class.from_pretrained(lowerCAmelCase__      ,    **lowerCAmelCase__     )

       UpperCAmelCase          =	tokenizer_r.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )
       UpperCAmelCase          =	tokenizer_p.encode(lowerCAmelCase__      ,    add_special_tokens=lowerCAmelCase__     )

       UpperCAmelCase          =	tokenizer_r.convert_ids_to_tokens(lowerCAmelCase__     )
       UpperCAmelCase          =	tokenizer_p.convert_ids_to_tokens(lowerCAmelCase__     )

       # it is expected that only the first Chinese character is not preceded by "##".
       UpperCAmelCase          =	[
           f"##{token}" if idx != 0 else token for idx, token in enumerate(lowerCAmelCase__     )
       ]
       self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )
       self.assertListEqual(lowerCAmelCase__      ,    lowerCAmelCase__     )






def   _lowerCAmelCase(						):

  for a in range(300      ):
    for b in range(a + 1 ,							400      ):
      for c in range(b + 1 ,							500      ):
        if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
          return a * b * c

  return -1
def   _lowerCAmelCase(						):

  for a in range(300      ):
    for b in range(400      ):
      UpperCAmelCase          =	1000 - a - b
      if a < b < c and (a**2) + (b**2) == (c**2):
        return a * b * c

  return -1
def   _lowerCAmelCase(						):
  import timeit

  print(
      timeit.timeit("solution()" ,							setup="from __main__ import solution" ,							number=1000      )      )
  print(
      timeit.timeit(
          "solution_fast()" ,							setup="from __main__ import solution_fast" ,							number=1000      )      )


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



