



"""simple docstring"""






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


_lowercase				:				Any   		=		get_tests_dir("fixtures/dummy_feature_extractor_config.json")
_lowercase				:				Dict   		=		get_tests_dir("fixtures/vocab.json")
_lowercase				:				List[str]   		=		get_tests_dir("fixtures")

class  __SCREAMING_SNAKE_CASE			(   unittest.TestCase     ):


					'''simple docstring'''





					_a         =							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']



					def 	snake_case ( self							:						int  )->      str:
								lowerCamelCase__	:	List[str]				=0



					def 	snake_case ( self							:						Optional[int]  )->      Optional[Any]:
								lowerCamelCase__	:	List[str]				=AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h'''  )
								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



					def 	snake_case ( self							:						List[Any]  )->      str:
								with tempfile.TemporaryDirectory() as tmpdirname:
											lowerCamelCase__	:	Tuple				=WavaVecaConfig()
											lowerCamelCase__	:	str				=AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h'''  )

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

											lowerCamelCase__	:	Tuple				=AutoProcessor.from_pretrained(lowerCamelCase  )

								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



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

											lowerCamelCase__	:	int				=AutoProcessor.from_pretrained(lowerCamelCase  )

								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



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

											lowerCamelCase__	:	Tuple				=WavaVecaProcessor(lowerCamelCase,						lowerCamelCase  )

											# save in new folder
											processor.save_pretrained(lowerCamelCase  )

											# drop `processor_class` in tokenizer
											with open(os.path.join(lowerCamelCase,						lowerCamelCase  ),						'''r'''  ) as f:
														lowerCamelCase__	:	Optional[Any]				=json.load(lowerCamelCase  )
														config_dict.pop('''processor_class'''  )

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

											lowerCamelCase__	:	Union[str, Any]				=AutoProcessor.from_pretrained(lowerCamelCase  )

								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



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

											lowerCamelCase__	:	Union[str, Any]				=WavaVecaProcessor(lowerCamelCase,						lowerCamelCase  )

											# save in new folder
											processor.save_pretrained(lowerCamelCase  )

											# drop `processor_class` in feature extractor
											with open(os.path.join(lowerCamelCase,						lowerCamelCase  ),						'''r'''  ) as f:
														lowerCamelCase__	:	Union[str, Any]				=json.load(lowerCamelCase  )
														config_dict.pop('''processor_class'''  )

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

											lowerCamelCase__	:	Any				=AutoProcessor.from_pretrained(lowerCamelCase  )

								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



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

											lowerCamelCase__	:	Any				=AutoProcessor.from_pretrained(lowerCamelCase  )

								self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )



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

								lowerCamelCase__	:	Any				=AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor''',						trust_remote_code=lowerCamelCase  )
								self.assertTrue(processor.special_attribute_present  )
								self.assertEqual(processor.__class__.__name__,						'''NewProcessor'''  )

								lowerCamelCase__	:	List[Any]				=processor.feature_extractor
								self.assertTrue(feature_extractor.special_attribute_present  )
								self.assertEqual(feature_extractor.__class__.__name__,						'''NewFeatureExtractor'''  )

								lowerCamelCase__	:	Dict				=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
											lowerCamelCase__	:	Optional[Any]				=AutoProcessor.from_pretrained(
											    '''hf-internal-testing/test_dynamic_processor''',						trust_remote_code=lowerCamelCase,						use_fast=lowerCamelCase  )
											lowerCamelCase__	:	Tuple				=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 	snake_case ( self							:						Any  )->      List[str]:
								try:
											AutoConfig.register('''custom''',						lowerCamelCase  )
											AutoFeatureExtractor.register(lowerCamelCase,						lowerCamelCase  )
											AutoTokenizer.register(lowerCamelCase,						slow_tokenizer_class=lowerCamelCase  )
											AutoProcessor.register(lowerCamelCase,						lowerCamelCase  )
											# Trying to register something existing in the Transformers library will raise an error
											with self.assertRaises(lowerCamelCase  ):
														AutoProcessor.register(lowerCamelCase,						lowerCamelCase  )

											# Now that the config is registered, it can be used as any other config with the auto-API
											lowerCamelCase__	:	List[str]				=CustomFeatureExtractor.from_pretrained(lowerCamelCase  )

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

											lowerCamelCase__	:	Optional[Any]				=CustomProcessor(lowerCamelCase,						lowerCamelCase  )

											with tempfile.TemporaryDirectory() as tmp_dir:
														processor.save_pretrained(lowerCamelCase  )
														lowerCamelCase__	:	List[str]				=AutoProcessor.from_pretrained(lowerCamelCase  )
														self.assertIsInstance(lowerCamelCase,						lowerCamelCase  )

								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 	snake_case ( self							:						Tuple  )->      Optional[Any]:

								class  __SCREAMING_SNAKE_CASE			(   lowerCAmelCase_     ):


													'''simple docstring'''





													_a         =							False





								class  __SCREAMING_SNAKE_CASE			(   lowerCAmelCase_     ):


													'''simple docstring'''





													_a         =							False





								class  __SCREAMING_SNAKE_CASE			(   lowerCAmelCase_     ):


													'''simple docstring'''





													_a         =							'AutoFeatureExtractor'
													_a         =							'AutoTokenizer'
													_a         =							False

								try:
											AutoConfig.register('''custom''',						lowerCamelCase  )
											AutoFeatureExtractor.register(lowerCamelCase,						lowerCamelCase  )
											AutoTokenizer.register(lowerCamelCase,						slow_tokenizer_class=lowerCamelCase  )
											AutoProcessor.register(lowerCamelCase,						lowerCamelCase  )
											# If remote code is not set, the default is to use local classes.
											lowerCamelCase__	:	str				=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.
											lowerCamelCase__	:	Tuple				=AutoProcessor.from_pretrained(
											    '''hf-internal-testing/test_dynamic_processor''',						trust_remote_code=lowerCamelCase  )
											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.
											lowerCamelCase__	:	str				=AutoProcessor.from_pretrained(
											    '''hf-internal-testing/test_dynamic_processor''',						trust_remote_code=lowerCamelCase  )
											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 	snake_case ( self							:						Union[str, Any]  )->      int:
								lowerCamelCase__	:	int				=AutoProcessor.from_pretrained('''hf-internal-testing/tiny-random-bert'''  )
								self.assertEqual(processor.__class__.__name__,						'''BertTokenizerFast'''  )




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





@is_staging_test
class  __SCREAMING_SNAKE_CASE			(   unittest.TestCase     ):


					'''simple docstring'''





					_a         =							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']



					@classmethod
					def 	snake_case ( cls							:						Dict  )->      str:
								lowerCamelCase__	:	int				=TOKEN
								HfFolder.save_token(lowerCamelCase  )



					@classmethod
					def 	snake_case ( cls							:						Tuple  )->      Dict:
								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 	snake_case ( self							:						Any  )->      int:
								lowerCamelCase__	:	Optional[int]				=WavaVecaProcessor.from_pretrained(lowerCamelCase  )
								with tempfile.TemporaryDirectory() as tmp_dir:
											processor.save_pretrained(
											    os.path.join(lowerCamelCase,						'''test-processor'''  ),						push_to_hub=lowerCamelCase,						use_auth_token=self._token  )

											lowerCamelCase__	:	Union[str, Any]				=WavaVecaProcessor.from_pretrained(F'''{USER}/test-processor'''  )
											for k, v in processor.feature_extractor.__dict__.items():
														self.assertEqual(lowerCamelCase,						getattr(new_processor.feature_extractor,						lowerCamelCase  )  )
											self.assertDictEqual(new_processor.tokenizer.get_vocab(),						processor.tokenizer.get_vocab()  )



					def 	snake_case ( self							:						Dict  )->      List[str]:
								lowerCamelCase__	:	List[str]				=WavaVecaProcessor.from_pretrained(lowerCamelCase  )

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

											lowerCamelCase__	:	List[Any]				=WavaVecaProcessor.from_pretrained('''valid_org/test-processor-org'''  )
											for k, v in processor.feature_extractor.__dict__.items():
														self.assertEqual(lowerCamelCase,						getattr(new_processor.feature_extractor,						lowerCamelCase  )  )
											self.assertDictEqual(new_processor.tokenizer.get_vocab(),						processor.tokenizer.get_vocab()  )




					def 	snake_case ( self							:						Any  )->      str:
								CustomFeatureExtractor.register_for_auto_class()
								CustomTokenizer.register_for_auto_class()
								CustomProcessor.register_for_auto_class()

								lowerCamelCase__	:	Tuple				=CustomFeatureExtractor.from_pretrained(lowerCamelCase  )

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

								lowerCamelCase__	:	Optional[Any]				=CustomProcessor(lowerCamelCase,						lowerCamelCase  )

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

											# 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(lowerCamelCase,						'''tokenizer_config.json'''  )  ) as f:
														lowerCamelCase__	:	Dict				=json.load(lowerCamelCase  )
											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(lowerCamelCase,						'''custom_feature_extraction.py'''  )  )  )
											self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase,						'''custom_tokenization.py'''  )  )  )
											self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase,						'''custom_processing.py'''  )  )  )

											repo.push_to_hub()

								lowerCamelCase__	:	Union[str, Any]				=AutoProcessor.from_pretrained(F'''{USER}/test-dynamic-processor''',						trust_remote_code=lowerCamelCase  )
								# 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'''  )









"""simple docstring"""






def   snake_case__     (	__lowerCamelCase       :					int = 10							,	__lowerCamelCase       :					int = 22			):
			"""simple docstring"""
			lowerCamelCase__	:	Optional[Any]				=range(1							,	__lowerCamelCase			)
			lowerCamelCase__	:	str				=range(1							,	__lowerCamelCase			)
			return sum(
			    1 for power in powers for base in bases if len(str(base**power			)			) == power			)


if __name__ == "__main__":
		print(f'{solution(1_0, 2_2) = }')




