





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


UpperCAmelCase__  :     List[Any]   			=get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
UpperCAmelCase__  :     List[Any]   			=get_tests_dir('''fixtures/vocab.json''')
UpperCAmelCase__  :     Union[str, Any]   			=get_tests_dir('''fixtures''')

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


				def _snake_case    (						self							):
								lowerCamelCase			=0


				def _snake_case    (						self							):
								lowerCamelCase			=AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""							)
								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								with tempfile.TemporaryDirectory() as tmpdirname:
												lowerCamelCase			=WavaVecaConfig()
												lowerCamelCase			=AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""							)

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

												lowerCamelCase			=AutoProcessor.from_pretrained(__UpperCamelCase							)

								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								with tempfile.TemporaryDirectory() as tmpdirname:
												# copy relevant files
												copyfile(__UpperCamelCase				,	os.path.join(__UpperCamelCase				,	__UpperCamelCase							)							)
												copyfile(__UpperCamelCase				,	os.path.join(__UpperCamelCase				,	"""vocab.json"""							)							)

												lowerCamelCase			=AutoProcessor.from_pretrained(__UpperCamelCase							)

								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								with tempfile.TemporaryDirectory() as tmpdirname:
												lowerCamelCase			=WavaVecaFeatureExtractor()
												lowerCamelCase			=AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h"""							)

												lowerCamelCase			=WavaVecaProcessor(__UpperCamelCase				,	__UpperCamelCase							)

												# save in new folder
												processor.save_pretrained(__UpperCamelCase							)

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

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

												lowerCamelCase			=AutoProcessor.from_pretrained(__UpperCamelCase							)

								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								with tempfile.TemporaryDirectory() as tmpdirname:
												lowerCamelCase			=WavaVecaFeatureExtractor()
												lowerCamelCase			=AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h"""							)

												lowerCamelCase			=WavaVecaProcessor(__UpperCamelCase				,	__UpperCamelCase							)

												# save in new folder
												processor.save_pretrained(__UpperCamelCase							)

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

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

												lowerCamelCase			=AutoProcessor.from_pretrained(__UpperCamelCase							)

								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								with tempfile.TemporaryDirectory() as tmpdirname:
												lowerCamelCase			=WavaVecaConfig(processor_class="""Wav2Vec2Processor"""							)
												model_config.save_pretrained(__UpperCamelCase							)
												# copy relevant files
												copyfile(__UpperCamelCase				,	os.path.join(__UpperCamelCase				,	"""vocab.json"""							)							)
												# create emtpy sample processor
												with open(os.path.join(__UpperCamelCase				,	__UpperCamelCase							)				,	"""w"""							) as f:
																f.write("""{}"""							)

												lowerCamelCase			=AutoProcessor.from_pretrained(__UpperCamelCase							)

								self.assertIsInstance(__UpperCamelCase				,	__UpperCamelCase							)


				def _snake_case    (						self							):
								# If remote code is not set, we will time out when asking whether to load the model.
								with self.assertRaises(__UpperCamelCase							):
												lowerCamelCase			=AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor"""							)
								# If remote code is disabled, we can't load this config.
								with self.assertRaises(__UpperCamelCase							):
												lowerCamelCase			=AutoProcessor.from_pretrained(
												    """hf-internal-testing/test_dynamic_processor"""				,	trust_remote_code=__UpperCamelCase							)

								lowerCamelCase			=AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor"""				,	trust_remote_code=__UpperCamelCase							)
								self.assertTrue(processor.special_attribute_present							)
								self.assertEqual(processor.__class__.__name__				,	"""NewProcessor"""							)

								lowerCamelCase			=processor.feature_extractor
								self.assertTrue(feature_extractor.special_attribute_present							)
								self.assertEqual(feature_extractor.__class__.__name__				,	"""NewFeatureExtractor"""							)

								lowerCamelCase			=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			=AutoProcessor.from_pretrained(
												    """hf-internal-testing/test_dynamic_processor"""				,	trust_remote_code=__UpperCamelCase				,	use_fast=__UpperCamelCase							)
												lowerCamelCase			=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							):
								try:
												AutoConfig.register("""custom"""				,	__UpperCamelCase							)
												AutoFeatureExtractor.register(__UpperCamelCase				,	__UpperCamelCase							)
												AutoTokenizer.register(__UpperCamelCase				,	slow_tokenizer_class=__UpperCamelCase							)
												AutoProcessor.register(__UpperCamelCase				,	__UpperCamelCase							)
												# Trying to register something existing in the Transformers library will raise an error
												with self.assertRaises(__UpperCamelCase							):
																AutoProcessor.register(__UpperCamelCase				,	__UpperCamelCase							)

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

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

												lowerCamelCase			=CustomProcessor(__UpperCamelCase				,	__UpperCamelCase							)

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

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

								class  __A       (  _lowercase      ):
												__A								=			False




								class  __A       (  _lowercase      ):
												__A								=			False




								class  __A       (  _lowercase      ):
												__A								=			"""AutoFeatureExtractor"""
												__A								=			"""AutoTokenizer"""
												__A								=			False

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


				def _snake_case    (						self							):
								lowerCamelCase			=AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-convnext"""							)
								self.assertEqual(processor.__class__.__name__				,	"""ConvNextImageProcessor"""							)




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


				@classmethod
				def _snake_case    (						cls							):
								lowerCamelCase			=TOKEN
								HfFolder.save_token(__UpperCamelCase							)


				@classmethod
				def _snake_case    (						cls							):
								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							):
								lowerCamelCase			=WavaVecaProcessor.from_pretrained(__UpperCamelCase							)
								with tempfile.TemporaryDirectory() as tmp_dir:
												processor.save_pretrained(
												    os.path.join(__UpperCamelCase				,	"""test-processor"""							)				,	push_to_hub=__UpperCamelCase				,	use_auth_token=self._token							)

												lowerCamelCase			=WavaVecaProcessor.from_pretrained(f"""{USER}/test-processor"""							)
												for k, v in processor.feature_extractor.__dict__.items():
																self.assertEqual(__UpperCamelCase				,	getattr(new_processor.feature_extractor				,	__UpperCamelCase							)							)
												self.assertDictEqual(new_processor.tokenizer.get_vocab()				,	processor.tokenizer.get_vocab()							)


				def _snake_case    (						self							):
								lowerCamelCase			=WavaVecaProcessor.from_pretrained(__UpperCamelCase							)

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

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


				def _snake_case    (						self							):
								CustomFeatureExtractor.register_for_auto_class()
								CustomTokenizer.register_for_auto_class()
								CustomProcessor.register_for_auto_class()

								lowerCamelCase			=CustomFeatureExtractor.from_pretrained(__UpperCamelCase							)

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

								lowerCamelCase			=CustomProcessor(__UpperCamelCase				,	__UpperCamelCase							)

								with tempfile.TemporaryDirectory() as tmp_dir:
												create_repo(f"""{USER}/test-dynamic-processor"""				,	token=self._token							)
												lowerCamelCase			=Repository(__UpperCamelCase				,	clone_from=f"""{USER}/test-dynamic-processor"""				,	token=self._token							)
												processor.save_pretrained(__UpperCamelCase							)

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

												repo.push_to_hub()

								lowerCamelCase			=AutoProcessor.from_pretrained(f"""{USER}/test-dynamic-processor"""				,	trust_remote_code=__UpperCamelCase							)
								# 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"""							)












import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text





def        _lowercase   (  _UpperCAmelCase			)  ->					str:
				lowerCamelCase			=[]
				for line in lines:
								lowerCamelCase			=re.sub(r"""#.*"""     , """"""     , _UpperCAmelCase			)  # remove comments
								if line:
												filtered_lines.append(_UpperCAmelCase			)
				lowerCamelCase			="""\n""".join(_UpperCAmelCase			)

				# Make a hash from all this code
				lowerCamelCase			=full_str.encode("""utf-8"""			)
				return shaaaa(_UpperCAmelCase			).hexdigest()


# get importable module names and hash for caching
UpperCAmelCase__  :     str   			={
    '''csv''': (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    '''json''': (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    '''pandas''': (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    '''parquet''': (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    '''arrow''': (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    '''text''': (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    '''imagefolder''': (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    '''audiofolder''': (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
UpperCAmelCase__  :     Tuple   			={
    '''.csv''': ('''csv''', {}),
    '''.tsv''': ('''csv''', {'''sep''': '''\t'''}),
    '''.json''': ('''json''', {}),
    '''.jsonl''': ('''json''', {}),
    '''.parquet''': ('''parquet''', {}),
    '''.arrow''': ('''arrow''', {}),
    '''.txt''': ('''text''', {}),
}
_EXTENSION_TO_MODULE.update({ext: ('''imagefolder''', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('''imagefolder''', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ('''audiofolder''', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('''audiofolder''', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
UpperCAmelCase__  :     Optional[Any]   			={'''imagefolder''', '''audiofolder'''}

# Used to filter data files based on extensions given a module name
UpperCAmelCase__  :     Dict[str, List[str]]   			={}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
							_MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append('''.zip''')




_MODULE_TO_EXTENSIONS["audiofolder"].append('''.zip''')





