import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
  from test_module.custom_tokenization_fast import CustomTokenizerFast
class    A_ (       unittest.TestCase ):

  def 		_UpperCAmelCase   (		self :      Any       ):
   # A mock response for an HTTP head request to emulate server down
   __a       =  mock.Mock()
   __a       =  5_00
   __a       =  {}
   __a       =  HTTPError
   __a       =  {}

   # Download this model to make sure it's in the cache.
   __a       =  BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"       )

   # Under the mock environment we get a 500 error when trying to reach the tokenizer.
   with mock.patch("requests.Session.request"     ,							return_value=__SCREAMING_SNAKE_CASE       ) as mock_head:
    __a       =  BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"       )
    # This check we did call the fake head request
    mock_head.assert_called()

  @require_tokenizers
  def 		_UpperCAmelCase   (		self :      Any       ):
   # A mock response for an HTTP head request to emulate server down
   __a       =  mock.Mock()
   __a       =  5_00
   __a       =  {}
   __a       =  HTTPError
   __a       =  {}

   # Download this model to make sure it's in the cache.
   __a       =  GPTaTokenizerFast.from_pretrained("gpt2"       )

   # Under the mock environment we get a 500 error when trying to reach the tokenizer.
   with mock.patch("requests.Session.request"     ,							return_value=__SCREAMING_SNAKE_CASE       ) as mock_head:
    __a       =  GPTaTokenizerFast.from_pretrained("gpt2"       )
    # This check we did call the fake head request
    mock_head.assert_called()

  def 		_UpperCAmelCase   (		self :      List[Any]       ):
   # This test is for deprecated behavior and can be removed in v5
   try:
    __a       =  tempfile.mktemp()
    with open(__SCREAMING_SNAKE_CASE     ,							"wb"       ) as f:
     http_get("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"     ,							__SCREAMING_SNAKE_CASE       )

    __a       =  AlbertTokenizer.from_pretrained(__SCREAMING_SNAKE_CASE       )
   finally:
    os.remove(__SCREAMING_SNAKE_CASE       )

   # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
   # the current folder and have the right name.
   if os.path.isfile("tokenizer.json"       ):
    # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
    return
   try:
    with open("tokenizer.json"     ,							"wb"       ) as f:
     http_get("https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json"     ,							__SCREAMING_SNAKE_CASE       )
    __a       =  AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"       )
    # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
    self.assertEqual(tokenizer.vocab_size     ,							10_00       )
    # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

   finally:
    os.remove("tokenizer.json"       )

  def 		_UpperCAmelCase   (		self :      List[Any]       ):
   # This test is for deprecated behavior and can be removed in v5
   __a       =  AlbertTokenizer.from_pretrained("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"       )
@is_staging_test
class    A_ (       unittest.TestCase ):
  _SCREAMING_SNAKE_CASE    				=			["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]

  @classmethod
  def 		_UpperCAmelCase   (		cls :      Union[str, Any]       ):
   __a       =  TOKEN
   HfFolder.save_token(__SCREAMING_SNAKE_CASE       )

  @classmethod
  def 		_UpperCAmelCase   (		cls :      Tuple       ):
   try:
    delete_repo(token=cls._token     ,							repo_id="test-tokenizer"       )
   except HTTPError:
    pass

   try:
    delete_repo(token=cls._token     ,							repo_id="valid_org/test-tokenizer-org"       )
   except HTTPError:
    pass

   try:
    delete_repo(token=cls._token     ,							repo_id="test-dynamic-tokenizer"       )
   except HTTPError:
    pass

  def 		_UpperCAmelCase   (		self :      int       ):
   with tempfile.TemporaryDirectory() as tmp_dir:
    __a       =  os.path.join(__SCREAMING_SNAKE_CASE     ,							"vocab.txt"       )
    with open(__SCREAMING_SNAKE_CASE     ,							"w"     ,							encoding="utf-8"       ) as vocab_writer:
     vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )
    __a       =  BertTokenizer(__SCREAMING_SNAKE_CASE       )

   tokenizer.push_to_hub("test-tokenizer"     ,							use_auth_token=self._token       )
   __a       =  BertTokenizer.from_pretrained(f"""{USER}/test-tokenizer"""       )
   self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab       )

   # Reset repo
   delete_repo(token=self._token     ,							repo_id="test-tokenizer"       )

   # Push to hub via save_pretrained
   with tempfile.TemporaryDirectory() as tmp_dir:
    tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE     ,							repo_id="test-tokenizer"     ,							push_to_hub=__SCREAMING_SNAKE_CASE     ,							use_auth_token=self._token       )

   __a       =  BertTokenizer.from_pretrained(f"""{USER}/test-tokenizer"""       )
   self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab       )

  def 		_UpperCAmelCase   (		self :      int       ):
   with tempfile.TemporaryDirectory() as tmp_dir:
    __a       =  os.path.join(__SCREAMING_SNAKE_CASE     ,							"vocab.txt"       )
    with open(__SCREAMING_SNAKE_CASE     ,							"w"     ,							encoding="utf-8"       ) as vocab_writer:
     vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )
    __a       =  BertTokenizer(__SCREAMING_SNAKE_CASE       )

   tokenizer.push_to_hub("valid_org/test-tokenizer-org"     ,							use_auth_token=self._token       )
   __a       =  BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"       )
   self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab       )

   # Reset repo
   delete_repo(token=self._token     ,							repo_id="valid_org/test-tokenizer-org"       )

   # Push to hub via save_pretrained
   with tempfile.TemporaryDirectory() as tmp_dir:
    tokenizer.save_pretrained(
        __SCREAMING_SNAKE_CASE     ,							repo_id="valid_org/test-tokenizer-org"     ,							push_to_hub=__SCREAMING_SNAKE_CASE     ,							use_auth_token=self._token       )

   __a       =  BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"       )
   self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab       )

  @require_tokenizers
  def 		_UpperCAmelCase   (		self :      List[str]       ):
   CustomTokenizer.register_for_auto_class()
   with tempfile.TemporaryDirectory() as tmp_dir:
    __a       =  os.path.join(__SCREAMING_SNAKE_CASE     ,							"vocab.txt"       )
    with open(__SCREAMING_SNAKE_CASE     ,							"w"     ,							encoding="utf-8"       ) as vocab_writer:
     vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )
    __a       =  CustomTokenizer(__SCREAMING_SNAKE_CASE       )

   # No fast custom tokenizer
   tokenizer.push_to_hub("test-dynamic-tokenizer"     ,							use_auth_token=self._token       )

   __a       =  AutoTokenizer.from_pretrained(f"""{USER}/test-dynamic-tokenizer"""     ,							trust_remote_code=__SCREAMING_SNAKE_CASE       )
   # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
   self.assertEqual(tokenizer.__class__.__name__     ,							"CustomTokenizer"       )

   # Fast and slow custom tokenizer
   CustomTokenizerFast.register_for_auto_class()
   with tempfile.TemporaryDirectory() as tmp_dir:
    __a       =  os.path.join(__SCREAMING_SNAKE_CASE     ,							"vocab.txt"       )
    with open(__SCREAMING_SNAKE_CASE     ,							"w"     ,							encoding="utf-8"       ) as vocab_writer:
     vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )

    __a       =  BertTokenizerFast.from_pretrained(__SCREAMING_SNAKE_CASE       )
    bert_tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE       )
    __a       =  CustomTokenizerFast.from_pretrained(__SCREAMING_SNAKE_CASE       )

   tokenizer.push_to_hub("test-dynamic-tokenizer"     ,							use_auth_token=self._token       )

   __a       =  AutoTokenizer.from_pretrained(f"""{USER}/test-dynamic-tokenizer"""     ,							trust_remote_code=__SCREAMING_SNAKE_CASE       )
   # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
   self.assertEqual(tokenizer.__class__.__name__     ,							"CustomTokenizerFast"       )
   __a       =  AutoTokenizer.from_pretrained(
       f"""{USER}/test-dynamic-tokenizer"""     ,							use_fast=__SCREAMING_SNAKE_CASE     ,							trust_remote_code=__SCREAMING_SNAKE_CASE       )
   # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
   self.assertEqual(tokenizer.__class__.__name__     ,							"CustomTokenizer"       )
class    A_ (       unittest.TestCase ):

  def 		_UpperCAmelCase   (		self :      Optional[int]       ):
   __a       =  Trie()
   trie.add("Hello 友達"       )
   self.assertEqual(trie.data     ,							{"H": {"e": {"l": {"l": {"o": {" ": {"友": {"達": {"": 1}}}}}}}}}       )
   trie.add("Hello"       )
   trie.data
   self.assertEqual(trie.data     ,							{"H": {"e": {"l": {"l": {"o": {"": 1, " ": {"友": {"達": {"": 1}}}}}}}}}       )

  def 		_UpperCAmelCase   (		self :      Tuple       ):
   __a       =  Trie()
   self.assertEqual(trie.split("[CLS] This is a extra_id_100"       )     ,							["[CLS] This is a extra_id_100"]       )
   trie.add("[CLS]"       )
   trie.add("extra_id_1"       )
   trie.add("extra_id_100"       )
   self.assertEqual(trie.split("[CLS] This is a extra_id_100"       )     ,							["[CLS]", " This is a ", "extra_id_100"]       )

  def 		_UpperCAmelCase   (		self :      Optional[int]       ):
   __a       =  Trie()
   trie.add("A"       )
   self.assertEqual(trie.split("ABC"       )     ,							["A", "BC"]       )
   self.assertEqual(trie.split("BCA"       )     ,							["BC", "A"]       )

  def 		_UpperCAmelCase   (		self :      str       ):
   __a       =  Trie()
   trie.add("TOKEN]"       )
   trie.add("[SPECIAL_TOKEN]"       )
   self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"       )     ,							["This is something ", "[SPECIAL_TOKEN]"]       )

  def 		_UpperCAmelCase   (		self :      Dict       ):
   __a       =  Trie()
   trie.add("A"       )
   trie.add("P"       )
   trie.add("[SPECIAL_TOKEN]"       )
   self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"       )     ,							["This is something ", "[SPECIAL_TOKEN]"]       )

  def 		_UpperCAmelCase   (		self :      List[Any]       ):
   __a       =  Trie()
   trie.add("AB"       )
   trie.add("B"       )
   trie.add("C"       )
   self.assertEqual(trie.split("ABC"       )     ,							["AB", "C"]       )

  def 		_UpperCAmelCase   (		self :      List[str]       ):
   __a       =  Trie()
   trie.add("ABC"       )
   trie.add("B"       )
   trie.add("CD"       )
   self.assertEqual(trie.split("ABCD"       )     ,							["ABC", "D"]       )

  def 		_UpperCAmelCase   (		self :      Any       ):
   # Even if the offsets are wrong, we necessarily output correct string
   # parts.
   __a       =  Trie()
   __a       =  trie.cut_text("ABC"     ,							[0, 0, 2, 1, 2, 3]       )
   self.assertEqual(__SCREAMING_SNAKE_CASE     ,							["AB", "C"]       )



from __future__ import annotations



def   __A		(			_A					):



 """simple docstring"""


 __a       =  [True] * limit
 __a       =  False
 __a       =  False
 __a       =  True

 for i in range(3							,				int(limit**0.5 + 1					)							,				2					):
  __a       =  i * 2
  while index < limit:
   __a       =  False
   __a       =  index + i

 __a       =  [2]

 for i in range(3							,				_A							,				2					):
  if is_prime[i]:
   primes.append(_A					)

 return primes



def   __A		(			_A = 100_0000					):



 """simple docstring"""


 __a       =  prime_sieve(_A					)
 __a       =  0
 __a       =  0

 for i in range(len(_A					)					):
  for j in range(i + length							,				len(_A					)					):
   __a       =  sum(primes[i:j]					)
   if sol >= ceiling:
    break

   if sol in primes:
    __a       =  j - i
    __a       =  sol

 return largest


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


