





def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):
       assert isinstance(lowerCAmelCase    ,       lowerCAmelCase					), f'''The input value of [n={number}] is not an integer'''

       if number == 1:
              return 2
       elif number < 1:
              _UpperCamelCase              =						f'''The input value of [n={number}] has to be > 0'''
              raise ValueError(lowerCAmelCase					)
       else:
              _UpperCamelCase              =						sylvester(number - 1					)
              _UpperCamelCase              =						num - 1
              _UpperCamelCase              =						num
              return lower * upper + 1


if __name__ == "__main__":
       print(F'''The 8th number in Sylvester\'s sequence: {sylvester(8)}''')













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      ):





            """simple docstring"""

            _UpperCamelCase              =						mock.Mock()
            _UpperCamelCase              =						500
            _UpperCamelCase              =						{}
            _UpperCamelCase              =						HTTPError
            _UpperCamelCase              =						{}

            # Download this model to make sure it's in the cache.
            _UpperCamelCase              =						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=A      ) as mock_head:
                   _UpperCamelCase              =						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      ):





            """simple docstring"""

            _UpperCamelCase              =						mock.Mock()
            _UpperCamelCase              =						500
            _UpperCamelCase              =						{}
            _UpperCamelCase              =						HTTPError
            _UpperCamelCase              =						{}

            # Download this model to make sure it's in the cache.
            _UpperCamelCase              =						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=A      ) as mock_head:
                   _UpperCamelCase              =						GPTaTokenizerFast.from_pretrained('''gpt2'''      )
                   # This check we did call the fake head request
                   mock_head.assert_called()

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            try:
                   _UpperCamelCase              =						tempfile.mktemp()
                   with open(A,       '''wb'''      ) as f:
                          http_get('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''',       A      )

                   _UpperCamelCase              =						AlbertTokenizer.from_pretrained(A      )
            finally:
                   os.remove(A      )

            # 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''',       A      )
                   _UpperCamelCase              =						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,       1000      )
                   # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

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



     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						AlbertTokenizer.from_pretrained('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model'''      )






@is_staging_test
class  __A(						unittest.TestCase ):
     __A	  =       ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]

     @classmethod
     def 	_UpperCamelCase     (      cls      ):





            """simple docstring"""

            _UpperCamelCase              =						TOKEN
            HfFolder.save_token(A      )

     @classmethod
     def 	_UpperCamelCase     (      cls      ):





            """simple docstring"""

            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      ):





            """simple docstring"""

            with tempfile.TemporaryDirectory() as tmp_dir:
                   _UpperCamelCase              =						os.path.join(A,       '''vocab.txt'''      )
                   with open(A,       '''w''',       encoding='''utf-8'''      ) as vocab_writer:
                          vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]      )      )
                   _UpperCamelCase              =						BertTokenizer(A      )

            tokenizer.push_to_hub('''test-tokenizer''',       use_auth_token=self._token      )
            _UpperCamelCase              =						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(A,       repo_id='''test-tokenizer''',       push_to_hub=A,       use_auth_token=self._token      )

            _UpperCamelCase              =						BertTokenizer.from_pretrained(F'''{USER}/test-tokenizer'''      )
            self.assertDictEqual(new_tokenizer.vocab,       tokenizer.vocab      )

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            with tempfile.TemporaryDirectory() as tmp_dir:
                   _UpperCamelCase              =						os.path.join(A,       '''vocab.txt'''      )
                   with open(A,       '''w''',       encoding='''utf-8'''      ) as vocab_writer:
                          vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]      )      )
                   _UpperCamelCase              =						BertTokenizer(A      )

            tokenizer.push_to_hub('''valid_org/test-tokenizer-org''',       use_auth_token=self._token      )
            _UpperCamelCase              =						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(
                       A,       repo_id='''valid_org/test-tokenizer-org''',       push_to_hub=A,       use_auth_token=self._token      )

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



     @require_tokenizers
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            CustomTokenizer.register_for_auto_class()
            with tempfile.TemporaryDirectory() as tmp_dir:
                   _UpperCamelCase              =						os.path.join(A,       '''vocab.txt'''      )
                   with open(A,       '''w''',       encoding='''utf-8'''      ) as vocab_writer:
                          vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]      )      )
                   _UpperCamelCase              =						CustomTokenizer(A      )

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

            _UpperCamelCase              =						AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer''',       trust_remote_code=A      )
            # 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:
                   _UpperCamelCase              =						os.path.join(A,       '''vocab.txt'''      )
                   with open(A,       '''w''',       encoding='''utf-8'''      ) as vocab_writer:
                          vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]      )      )

                   _UpperCamelCase              =						BertTokenizerFast.from_pretrained(A      )
                   bert_tokenizer.save_pretrained(A      )
                   _UpperCamelCase              =						CustomTokenizerFast.from_pretrained(A      )

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

            _UpperCamelCase              =						AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer''',       trust_remote_code=A      )
            # 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'''      )
            _UpperCamelCase              =						AutoTokenizer.from_pretrained(
                F'''{USER}/test-dynamic-tokenizer''',       use_fast=A,       trust_remote_code=A      )
            # 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      ):





            """simple docstring"""

            _UpperCamelCase              =						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      ):





            """simple docstring"""

            _UpperCamelCase              =						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      ):





            """simple docstring"""

            _UpperCamelCase              =						Trie()
            trie.add('''A'''      )
            self.assertEqual(trie.split('''ABC'''      ),       ['''A''', '''BC''']      )
            self.assertEqual(trie.split('''BCA'''      ),       ['''BC''', '''A''']      )

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						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      ):





            """simple docstring"""

            _UpperCamelCase              =						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      ):





            """simple docstring"""

            _UpperCamelCase              =						Trie()
            trie.add('''AB'''      )
            trie.add('''B'''      )
            trie.add('''C'''      )
            self.assertEqual(trie.split('''ABC'''      ),       ['''AB''', '''C''']      )

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						Trie()
            trie.add('''ABC'''      )
            trie.add('''B'''      )
            trie.add('''CD'''      )
            self.assertEqual(trie.split('''ABCD'''      ),       ['''ABC''', '''D''']      )



     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						Trie()
            _UpperCamelCase              =						trie.cut_text('''ABC''',       [0, 0, 2, 1, 2, 3]      )
            self.assertEqual(A,       ['''AB''', '''C''']      )






