


import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


snake_case							: str      =   get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
snake_case							: Optional[int]      =   get_tests_dir('''fixtures/vocab.json''')
snake_case							: Tuple      =   get_tests_dir('''fixtures''')







class  snake_case_     (unittest.TestCase   ):
     UpperCAmelCase__      :					Tuple					   =    ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]
     def 				lowerCamelCase__(   self     :Tuple   )      ->					Union[str, Any]:
            a__    =  0
     def 				lowerCamelCase__(   self     :List[Any]   )      ->					str:
            a__    =  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'   )
            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :List[Any]   )      ->					Tuple:
            with tempfile.TemporaryDirectory() as tmpdirname:
                   a__    =  WavaVecaConfig()
                   a__    =  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'   )

                   # save in new folder
                   model_config.save_pretrained(__lowercase   )
                   processor.save_pretrained(__lowercase   )

                   a__    =  AutoProcessor.from_pretrained(__lowercase   )

            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					List[str]:
            with tempfile.TemporaryDirectory() as tmpdirname:
                   # copy relevant files
                   copyfile(__lowercase    ,os.path.join(__lowercase    ,__lowercase   )   )
                   copyfile(__lowercase    ,os.path.join(__lowercase    ,'vocab.json'   )   )

                   a__    =  AutoProcessor.from_pretrained(__lowercase   )

            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :List[str]   )      ->					List[str]:
            with tempfile.TemporaryDirectory() as tmpdirname:
                   a__    =  WavaVecaFeatureExtractor()
                   a__    =  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'   )

                   a__    =  WavaVecaProcessor(__lowercase    ,__lowercase   )

                   # save in new folder
                   processor.save_pretrained(__lowercase   )

                   # drop `processor_class` in tokenizer
                   with open(os.path.join(__lowercase    ,__lowercase   )    ,'r'   ) as f:
                          a__    =  json.load(__lowercase   )
                          config_dict.pop('processor_class'   )

                   with open(os.path.join(__lowercase    ,__lowercase   )    ,'w'   ) as f:
                          f.write(json.dumps(__lowercase   )   )

                   a__    =  AutoProcessor.from_pretrained(__lowercase   )

            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :Dict   )      ->					Union[str, Any]:
            with tempfile.TemporaryDirectory() as tmpdirname:
                   a__    =  WavaVecaFeatureExtractor()
                   a__    =  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'   )

                   a__    =  WavaVecaProcessor(__lowercase    ,__lowercase   )

                   # save in new folder
                   processor.save_pretrained(__lowercase   )

                   # drop `processor_class` in feature extractor
                   with open(os.path.join(__lowercase    ,__lowercase   )    ,'r'   ) as f:
                          a__    =  json.load(__lowercase   )
                          config_dict.pop('processor_class'   )

                   with open(os.path.join(__lowercase    ,__lowercase   )    ,'w'   ) as f:
                          f.write(json.dumps(__lowercase   )   )

                   a__    =  AutoProcessor.from_pretrained(__lowercase   )

            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :Dict   )      ->					str:
            with tempfile.TemporaryDirectory() as tmpdirname:
                   a__    =  WavaVecaConfig(processor_class='Wav2Vec2Processor'   )
                   model_config.save_pretrained(__lowercase   )
                   # copy relevant files
                   copyfile(__lowercase    ,os.path.join(__lowercase    ,'vocab.json'   )   )
                   # create emtpy sample processor
                   with open(os.path.join(__lowercase    ,__lowercase   )    ,'w'   ) as f:
                          f.write('{}'   )

                   a__    =  AutoProcessor.from_pretrained(__lowercase   )

            self.assertIsInstance(__lowercase    ,__lowercase   )
     def 				lowerCamelCase__(   self     :List[Any]   )      ->					Tuple:
            # If remote code is not set, we will time out when asking whether to load the model.
            with self.assertRaises(__lowercase   ):
                   a__    =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'   )
            # If remote code is disabled, we can't load this config.
            with self.assertRaises(__lowercase   ):
                   a__    =  AutoProcessor.from_pretrained(
                       'hf-internal-testing/test_dynamic_processor'    ,trust_remote_code=__lowercase   )

            a__    =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'    ,trust_remote_code=__lowercase   )
            self.assertTrue(processor.special_attribute_present   )
            self.assertEqual(processor.__class__.__name__    ,'NewProcessor'   )

            a__    =  processor.feature_extractor
            self.assertTrue(feature_extractor.special_attribute_present   )
            self.assertEqual(feature_extractor.__class__.__name__    ,'NewFeatureExtractor'   )

            a__    =  processor.tokenizer
            self.assertTrue(tokenizer.special_attribute_present   )
            if is_tokenizers_available():
                   self.assertEqual(tokenizer.__class__.__name__    ,'NewTokenizerFast'   )

                   # Test we can also load the slow version
                   a__    =  AutoProcessor.from_pretrained(
                       'hf-internal-testing/test_dynamic_processor'    ,trust_remote_code=__lowercase    ,use_fast=__lowercase   )
                   a__    =  new_processor.tokenizer
                   self.assertTrue(new_tokenizer.special_attribute_present   )
                   self.assertEqual(new_tokenizer.__class__.__name__    ,'NewTokenizer'   )
            else:
                   self.assertEqual(tokenizer.__class__.__name__    ,'NewTokenizer'   )
     def 				lowerCamelCase__(   self     :int   )      ->					Dict:
            try:
                   AutoConfig.register('custom'    ,__lowercase   )
                   AutoFeatureExtractor.register(__lowercase    ,__lowercase   )
                   AutoTokenizer.register(__lowercase    ,slow_tokenizer_class=__lowercase   )
                   AutoProcessor.register(__lowercase    ,__lowercase   )
                   # Trying to register something existing in the Transformers library will raise an error
                   with self.assertRaises(__lowercase   ):
                          AutoProcessor.register(__lowercase    ,__lowercase   )

                   # Now that the config is registered, it can be used as any other config with the auto-API
                   a__    =  CustomFeatureExtractor.from_pretrained(__lowercase   )

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

                   a__    =  CustomProcessor(__lowercase    ,__lowercase   )

                   with tempfile.TemporaryDirectory() as tmp_dir:
                          processor.save_pretrained(__lowercase   )
                          a__    =  AutoProcessor.from_pretrained(__lowercase   )
                          self.assertIsInstance(__lowercase    ,__lowercase   )

            finally:
                   if "custom" in CONFIG_MAPPING._extra_content:
                          del CONFIG_MAPPING._extra_content["custom"]
                   if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                          del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                   if CustomConfig in TOKENIZER_MAPPING._extra_content:
                          del TOKENIZER_MAPPING._extra_content[CustomConfig]
                   if CustomConfig in PROCESSOR_MAPPING._extra_content:
                          del PROCESSOR_MAPPING._extra_content[CustomConfig]
     def 				lowerCamelCase__(   self     :Dict   )      ->					Optional[Any]:







            class  snake_case_     (lowercase__   ):
                 UpperCAmelCase__      :					Union[str, Any]					   =    False







            class  snake_case_     (lowercase__   ):
                 UpperCAmelCase__      :					Dict					   =    False







            class  snake_case_     (lowercase__   ):
                 UpperCAmelCase__      :					Union[str, Any]					   =    """AutoFeatureExtractor"""
                 UpperCAmelCase__      :					List[str]					   =    """AutoTokenizer"""
                 UpperCAmelCase__      :					Union[str, Any]					   =    False

            try:
                   AutoConfig.register('custom'    ,__lowercase   )
                   AutoFeatureExtractor.register(__lowercase    ,__lowercase   )
                   AutoTokenizer.register(__lowercase    ,slow_tokenizer_class=__lowercase   )
                   AutoProcessor.register(__lowercase    ,__lowercase   )
                   # If remote code is not set, the default is to use local classes.
                   a__    =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'   )
                   self.assertEqual(processor.__class__.__name__    ,'NewProcessor'   )
                   self.assertFalse(processor.special_attribute_present   )
                   self.assertFalse(processor.feature_extractor.special_attribute_present   )
                   self.assertFalse(processor.tokenizer.special_attribute_present   )

                   # If remote code is disabled, we load the local ones.
                   a__    =  AutoProcessor.from_pretrained(
                       'hf-internal-testing/test_dynamic_processor'    ,trust_remote_code=__lowercase   )
                   self.assertEqual(processor.__class__.__name__    ,'NewProcessor'   )
                   self.assertFalse(processor.special_attribute_present   )
                   self.assertFalse(processor.feature_extractor.special_attribute_present   )
                   self.assertFalse(processor.tokenizer.special_attribute_present   )

                   # If remote is enabled, we load from the Hub.
                   a__    =  AutoProcessor.from_pretrained(
                       'hf-internal-testing/test_dynamic_processor'    ,trust_remote_code=__lowercase   )
                   self.assertEqual(processor.__class__.__name__    ,'NewProcessor'   )
                   self.assertTrue(processor.special_attribute_present   )
                   self.assertTrue(processor.feature_extractor.special_attribute_present   )
                   self.assertTrue(processor.tokenizer.special_attribute_present   )

            finally:
                   if "custom" in CONFIG_MAPPING._extra_content:
                          del CONFIG_MAPPING._extra_content["custom"]
                   if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                          del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                   if CustomConfig in TOKENIZER_MAPPING._extra_content:
                          del TOKENIZER_MAPPING._extra_content[CustomConfig]
                   if CustomConfig in PROCESSOR_MAPPING._extra_content:
                          del PROCESSOR_MAPPING._extra_content[CustomConfig]
     def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					int:
            a__    =  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert'   )
            self.assertEqual(processor.__class__.__name__    ,'BertTokenizerFast'   )



     def 				lowerCamelCase__(   self     :str   )      ->					Union[str, Any]:
            a__    =  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-convnext'   )
            self.assertEqual(processor.__class__.__name__    ,'ConvNextImageProcessor'   )







@is_staging_test
class  snake_case_     (unittest.TestCase   ):
     UpperCAmelCase__      :					List[Any]					   =    ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]
     @classmethod
     def 				lowerCamelCase__(   cls     :Union[str, Any]   )      ->					List[str]:
            a__    =  TOKEN
            HfFolder.save_token(__lowercase   )
     @classmethod
     def 				lowerCamelCase__(   cls     :int   )      ->					List[str]:
            try:
                   delete_repo(token=cls._token    ,repo_id='test-processor'   )
            except HTTPError:
                   pass

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

            try:
                   delete_repo(token=cls._token    ,repo_id='test-dynamic-processor'   )
            except HTTPError:
                   pass
     def 				lowerCamelCase__(   self     :Dict   )      ->					str:
            a__    =  WavaVecaProcessor.from_pretrained(__lowercase   )
            with tempfile.TemporaryDirectory() as tmp_dir:
                   processor.save_pretrained(
                       os.path.join(__lowercase    ,'test-processor'   )    ,push_to_hub=__lowercase    ,use_auth_token=self._token   )

                   a__    =  WavaVecaProcessor.from_pretrained(F'{USER}/test-processor'   )
                   for k, v in processor.feature_extractor.__dict__.items():
                          self.assertEqual(__lowercase    ,getattr(new_processor.feature_extractor    ,__lowercase   )   )
                   self.assertDictEqual(new_processor.tokenizer.get_vocab()    ,processor.tokenizer.get_vocab()   )
     def 				lowerCamelCase__(   self     :Tuple   )      ->					str:
            a__    =  WavaVecaProcessor.from_pretrained(__lowercase   )

            with tempfile.TemporaryDirectory() as tmp_dir:
                   processor.save_pretrained(
                       os.path.join(__lowercase    ,'test-processor-org'   )    ,push_to_hub=__lowercase    ,use_auth_token=self._token    ,organization='valid_org'    ,)

                   a__    =  WavaVecaProcessor.from_pretrained('valid_org/test-processor-org'   )
                   for k, v in processor.feature_extractor.__dict__.items():
                          self.assertEqual(__lowercase    ,getattr(new_processor.feature_extractor    ,__lowercase   )   )
                   self.assertDictEqual(new_processor.tokenizer.get_vocab()    ,processor.tokenizer.get_vocab()   )



     def 				lowerCamelCase__(   self     :List[Any]   )      ->					str:
            CustomFeatureExtractor.register_for_auto_class()
            CustomTokenizer.register_for_auto_class()
            CustomProcessor.register_for_auto_class()

            a__    =  CustomFeatureExtractor.from_pretrained(__lowercase   )

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

            a__    =  CustomProcessor(__lowercase    ,__lowercase   )

            with tempfile.TemporaryDirectory() as tmp_dir:
                   create_repo(F'{USER}/test-dynamic-processor'    ,token=self._token   )
                   a__    =  Repository(__lowercase    ,clone_from=F'{USER}/test-dynamic-processor'    ,token=self._token   )
                   processor.save_pretrained(__lowercase   )

                   # This has added the proper auto_map field to the feature extractor config
                   self.assertDictEqual(
                       processor.feature_extractor.auto_map    ,{
                           'AutoFeatureExtractor': 'custom_feature_extraction.CustomFeatureExtractor',
                           'AutoProcessor': 'custom_processing.CustomProcessor',
                       }    ,)

                   # This has added the proper auto_map field to the tokenizer config
                   with open(os.path.join(__lowercase    ,'tokenizer_config.json'   )   ) as f:
                          a__    =  json.load(__lowercase   )
                   self.assertDictEqual(
                       tokenizer_config['auto_map']    ,{
                           'AutoTokenizer': ['custom_tokenization.CustomTokenizer', None],
                           'AutoProcessor': 'custom_processing.CustomProcessor',
                       }    ,)

                   # The code has been copied from fixtures
                   self.assertTrue(os.path.isfile(os.path.join(__lowercase    ,'custom_feature_extraction.py'   )   )   )
                   self.assertTrue(os.path.isfile(os.path.join(__lowercase    ,'custom_tokenization.py'   )   )   )
                   self.assertTrue(os.path.isfile(os.path.join(__lowercase    ,'custom_processing.py'   )   )   )

                   repo.push_to_hub()

            a__    =  AutoProcessor.from_pretrained(F'{USER}/test-dynamic-processor'    ,trust_remote_code=__lowercase   )
            # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
            self.assertEqual(new_processor.__class__.__name__    ,'CustomProcessor'   )








from math import sqrt






def 							__lowercase     (				__lowerCAmelCase							:       int     ):

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5      ,					int(sqrt(__lowerCAmelCase     ) + 1     )      ,					6     ):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True






def 							__lowercase     (				__lowerCAmelCase							:       int = 1_0_0_0_1     ):
							a__    =  0
							a__    =  1
							while count != nth and number < 3:
														number += 1
														if is_prime(__lowerCAmelCase     ):
																					count += 1
							while count != nth:
														number += 2
														if is_prime(__lowerCAmelCase     ):
																					count += 1
							return number


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




