


'''simple docstring'''


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__  (					lowerCAmelCase						,		unittest.TestCase   ):

     """simple docstring"""






     lowerCamelCase__						=							ElectraTokenizer
     lowerCamelCase__						=							ElectraTokenizerFast
     lowerCamelCase__						=							True
     lowerCamelCase__						=							True
     lowerCamelCase__						=							filter_non_english


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          super().setUp()

          __A  :					Any						     =       [
              "[UNK]",
              "[CLS]",
              "[SEP]",
              "[PAD]",
              "[MASK]",
              "want",
              "##want",
              "##ed",
              "wa",
              "un",
              "runn",
              "##ing",
              ",",
              "low",
              "lowest",
          ]
          __A  :					Dict						     =       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 lowerCAmelCase__     (      self ,    lowerCamelCase		):


          '''simple docstring'''





          __A  :					List[str]						     =       "UNwant\u00E9d,running"
          __A  :					str						     =       "unwanted, running"
          return input_text, output_text


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					int						     =       self.tokenizer_class(self.vocab_file		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          if not self.test_rust_tokenizer:
               return

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

          __A  :					str						     =       "UNwant\u00E9d,running"

          __A  :					List[str]						     =       tokenizer.tokenize(a_		)
          __A  :					Tuple						     =       rust_tokenizer.tokenize(a_		)
          self.assertListEqual(a_ ,    a_		)

          __A  :					List[Any]						     =       tokenizer.encode(a_ ,    add_special_tokens=a_		)
          __A  :					Dict						     =       rust_tokenizer.encode(a_ ,    add_special_tokens=a_		)
          self.assertListEqual(a_ ,    a_		)

          __A  :					Any						     =       self.get_rust_tokenizer()
          __A  :					Dict						     =       tokenizer.encode(a_		)
          __A  :					List[Any]						     =       rust_tokenizer.encode(a_		)
          self.assertListEqual(a_ ,    a_		)

          # With lower casing
          __A  :					List[str]						     =       self.get_tokenizer(do_lower_case=a_		)
          __A  :					Optional[int]						     =       self.get_rust_tokenizer(do_lower_case=a_		)

          __A  :					Union[str, Any]						     =       "UNwant\u00E9d,running"

          __A  :					Optional[Any]						     =       tokenizer.tokenize(a_		)
          __A  :					Optional[int]						     =       rust_tokenizer.tokenize(a_		)
          self.assertListEqual(a_ ,    a_		)

          __A  :					Dict						     =       tokenizer.encode(a_ ,    add_special_tokens=a_		)
          __A  :					Optional[Any]						     =       rust_tokenizer.encode(a_ ,    add_special_tokens=a_		)
          self.assertListEqual(a_ ,    a_		)

          __A  :					int						     =       self.get_rust_tokenizer()
          __A  :					List[Any]						     =       tokenizer.encode(a_		)
          __A  :					Tuple						     =       rust_tokenizer.encode(a_		)
          self.assertListEqual(a_ ,    a_		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Union[str, Any]						     =       BasicTokenizer()

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					List[Any]						     =       BasicTokenizer(do_lower_case=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Dict						     =       BasicTokenizer(do_lower_case=a_ ,    strip_accents=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[Any]						     =       BasicTokenizer(do_lower_case=a_ ,    strip_accents=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[int]						     =       BasicTokenizer(do_lower_case=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Union[str, Any]						     =       BasicTokenizer(do_lower_case=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Tuple						     =       BasicTokenizer(do_lower_case=a_ ,    strip_accents=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					str						     =       BasicTokenizer(do_lower_case=a_ ,    strip_accents=a_		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Tuple						     =       BasicTokenizer(do_lower_case=a_ ,    never_split=["[UNK]"]		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[int]						     =       ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

          __A  :					int						     =       {}
          for i, token in enumerate(a_		):
               __A  :					Dict						     =       i
          __A  :					List[str]						     =       WordpieceTokenizer(vocab=a_ ,    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 lowerCAmelCase__     (      self		):


          '''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 lowerCAmelCase__     (      self		):


          '''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 lowerCAmelCase__     (      self		):


          '''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 lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Any						     =       self.get_tokenizer()
          __A  :					Tuple						     =       self.get_rust_tokenizer()

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

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


     @slow
     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[int]						     =       self.tokenizer_class.from_pretrained("google/electra-base-discriminator"		)

          __A  :					List[Any]						     =       tokenizer.encode("sequence builders" ,    add_special_tokens=a_		)
          __A  :					Optional[int]						     =       tokenizer.encode("multi-sequence build" ,    add_special_tokens=a_		)

          __A  :					Any						     =       tokenizer.build_inputs_with_special_tokens(a_		)
          __A  :					str						     =       tokenizer.build_inputs_with_special_tokens(a_ ,    a_		)

          assert encoded_sentence == [101] + text + [102]
          assert encoded_pair == [101] + text + [102] + text_a + [102]


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"		):
                    __A  :					Tuple						     =       self.rust_tokenizer_class.from_pretrained(a_ ,    **a_		)

                    __A  :					int						     =       f"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
                    __A  :					int						     =       tokenizer_r.encode_plus(
                        a_ ,    return_attention_mask=a_ ,    return_token_type_ids=a_ ,    return_offsets_mapping=a_ ,    add_special_tokens=a_ ,    )

                    __A  :					Any						     =       tokenizer_r.do_lower_case if hasattr(a_ ,    "do_lower_case"		) else False
                    __A  :					List[Any]						     =       (
                        [
                            ((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 lowerCAmelCase__     (      self		):


          '''simple docstring'''





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

                    __A  :					int						     =       tokenizer_p.encode(a_ ,    add_special_tokens=a_		)
                    __A  :					Tuple						     =       tokenizer_r.encode(a_ ,    add_special_tokens=a_		)

                    __A  :					int						     =       tokenizer_r.convert_ids_to_tokens(a_		)
                    __A  :					Dict						     =       tokenizer_p.convert_ids_to_tokens(a_		)

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

                    __A  :					Tuple						     =       False
                    __A  :					str						     =       self.rust_tokenizer_class.from_pretrained(a_ ,    **a_		)
                    __A  :					Dict						     =       self.tokenizer_class.from_pretrained(a_ ,    **a_		)

                    __A  :					Optional[int]						     =       tokenizer_r.encode(a_ ,    add_special_tokens=a_		)
                    __A  :					str						     =       tokenizer_p.encode(a_ ,    add_special_tokens=a_		)

                    __A  :					str						     =       tokenizer_r.convert_ids_to_tokens(a_		)
                    __A  :					Dict						     =       tokenizer_p.convert_ids_to_tokens(a_		)

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





'''simple docstring'''


import math
from collections.abc import Generator


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)       ))
     for i in (n for n in numbers if n > 1):
          for j in range(2					,				SCREAMING_SNAKE_CASE       ):
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)       ))
     for i in (n for n in numbers if n > 1):
          # only need to check for factors up to sqrt(i)
          __A  :					Optional[Any]						     =       int(math.sqrt(SCREAMING_SNAKE_CASE       )       ) + 1
          for j in range(2					,				SCREAMING_SNAKE_CASE       ):
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Generator						     =       (i for i in range(1					,				(max_n + 1)					,				2       ))
     # It's useless to test even numbers as they will not be prime
     if max_n > 2:
          yield 2  # Because 2 will not be tested, it's necessary to yield it now
     for i in (n for n in numbers if n > 1):
          __A  :					List[str]						     =       int(math.sqrt(SCREAMING_SNAKE_CASE       )       ) + 1
          for j in range(3					,				SCREAMING_SNAKE_CASE					,				2       ):
               # As we removed the even numbers, we don't need them now
               if (i % j) == 0:
                    break
          else:
               yield i


def 		_lowercase   ():




     '''simple docstring'''





     from timeit import timeit

     __A  :					List[str]						     =       "from __main__ import slow_primes, primes, fast_primes"
     print(timeit("slow_primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )
     print(timeit("primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )
     print(timeit("fast_primes(1_000_000_000_000)"					,				setup=SCREAMING_SNAKE_CASE					,				number=100_0000       )       )


if __name__ == "__main__":
      _UpperCamelCase          =     int(input("""Calculate primes up to:\n>> """).strip())
      for ret in primes(number):
            print(ret)
      benchmark()

