





import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


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


UpperCAmelCase						:   Union[str, Any]			  =     get_tests_dir('''fixtures''')
UpperCAmelCase						:   Dict			  =     get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
UpperCAmelCase						:   List[str]			  =     get_tests_dir('''fixtures/dummy-config.json''')





class 						_A(					unittest.TestCase   ):


				"""simple docstring"""


				def 					UpperCAmelCase_		(			self     ):
									__A	:						Dict       =				0



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Dict       =				AutoFeatureExtractor.from_pretrained('facebook/wav2vec2-base-960h'     )
									self.assertIsInstance(_A     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[str]       =				AutoFeatureExtractor.from_pretrained(_A     )
									self.assertIsInstance(_A     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									with tempfile.TemporaryDirectory() as tmpdirname:
														__A	:						List[str]       =				WavaVecaConfig()

														# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
														__A	:						List[str]       =				AutoFeatureExtractor.from_pretrained(_A     ).to_dict()

														config_dict.pop('feature_extractor_type'     )
														__A	:						Optional[int]       =				WavaVecaFeatureExtractor(**_A     )

														# save in new folder
														model_config.save_pretrained(_A     )
														config.save_pretrained(_A     )

														__A	:						Optional[int]       =				AutoFeatureExtractor.from_pretrained(_A     )

														# make sure private variable is not incorrectly saved
														__A	:						Optional[int]       =				json.loads(config.to_json_string()     )
														self.assertTrue('_processor_class' not in dict_as_saved     )

									self.assertIsInstance(_A     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									__A	:						Optional[int]       =				AutoFeatureExtractor.from_pretrained(_A     )
									self.assertIsInstance(_A     ,					_A     )



				def 					UpperCAmelCase_		(			self     ):
									with self.assertRaisesRegex(
									    _A     ,					'bert-base is not a local folder and is not a valid model identifier'     ):
														__A	:						Any       =				AutoFeatureExtractor.from_pretrained('bert-base'     )



				def 					UpperCAmelCase_		(			self     ):
									with self.assertRaisesRegex(
									    _A     ,					R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'     ):
														__A	:						Union[str, Any]       =				AutoFeatureExtractor.from_pretrained(_A     ,					revision='aaaaaa'     )



				def 					UpperCAmelCase_		(			self     ):
									with self.assertRaisesRegex(
									    _A     ,					'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'     ,					):
														__A	:						Tuple       =				AutoFeatureExtractor.from_pretrained('hf-internal-testing/config-no-model'     )



				def 					UpperCAmelCase_		(			self     ):
									# If remote code is not set, we will time out when asking whether to load the model.
									with self.assertRaises(_A     ):
														__A	:						Any       =				AutoFeatureExtractor.from_pretrained(
														    'hf-internal-testing/test_dynamic_feature_extractor'     )
									# If remote code is disabled, we can't load this config.
									with self.assertRaises(_A     ):
														__A	:						str       =				AutoFeatureExtractor.from_pretrained(
														    'hf-internal-testing/test_dynamic_feature_extractor'     ,					trust_remote_code=_A     )

									__A	:						int       =				AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,					trust_remote_code=_A     )
									self.assertEqual(feature_extractor.__class__.__name__     ,					'NewFeatureExtractor'     )

									# Test feature extractor can be reloaded.
									with tempfile.TemporaryDirectory() as tmp_dir:
														feature_extractor.save_pretrained(_A     )
														__A	:						Dict       =				AutoFeatureExtractor.from_pretrained(_A     ,					trust_remote_code=_A     )
									self.assertEqual(reloaded_feature_extractor.__class__.__name__     ,					'NewFeatureExtractor'     )



				def 					UpperCAmelCase_		(			self     ):
									try:
														AutoConfig.register('custom'     ,					_A     )
														AutoFeatureExtractor.register(_A     ,					_A     )
														# Trying to register something existing in the Transformers library will raise an error
														with self.assertRaises(_A     ):
																			AutoFeatureExtractor.register(_A     ,					_A     )

														# Now that the config is registered, it can be used as any other config with the auto-API
														__A	:						Dict       =				CustomFeatureExtractor.from_pretrained(_A     )
														with tempfile.TemporaryDirectory() as tmp_dir:
																			feature_extractor.save_pretrained(_A     )
																			__A	:						Optional[int]       =				AutoFeatureExtractor.from_pretrained(_A     )
																			self.assertIsInstance(_A     ,					_A     )

									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]





				def 					UpperCAmelCase_		(			self     ):





									class 						_A(					snake_case__   ):


													"""simple docstring"""


													UpperCamelCase    :  Dict					    =	True

									try:
														AutoConfig.register('custom'     ,					_A     )
														AutoFeatureExtractor.register(_A     ,					_A     )
														# If remote code is not set, the default is to use local
														__A	:						Optional[Any]       =				AutoFeatureExtractor.from_pretrained(
														    'hf-internal-testing/test_dynamic_feature_extractor'     )
														self.assertEqual(feature_extractor.__class__.__name__     ,					'NewFeatureExtractor'     )
														self.assertTrue(feature_extractor.is_local     )

														# If remote code is disabled, we load the local one.
														__A	:						List[Any]       =				AutoFeatureExtractor.from_pretrained(
														    'hf-internal-testing/test_dynamic_feature_extractor'     ,					trust_remote_code=_A     )
														self.assertEqual(feature_extractor.__class__.__name__     ,					'NewFeatureExtractor'     )
														self.assertTrue(feature_extractor.is_local     )

														# If remote is enabled, we load from the Hub
														__A	:						List[str]       =				AutoFeatureExtractor.from_pretrained(
														    'hf-internal-testing/test_dynamic_feature_extractor'     ,					trust_remote_code=_A     )
														self.assertEqual(feature_extractor.__class__.__name__     ,					'NewFeatureExtractor'     )
														self.assertTrue(not hasattr(_A     ,					'is_local'     )     )

									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]











from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCAmelCase						:   Any			  =     {
    '''configuration_falcon''': ['''FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FalconConfig'''],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCAmelCase						:   Any			  =     [
				    '''FALCON_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''FalconForCausalLM''',
				    '''FalconModel''',
				    '''FalconPreTrainedModel''',
				    '''FalconForSequenceClassification''',
				    '''FalconForTokenClassification''',
				    '''FalconForQuestionAnswering''',
				]


if TYPE_CHECKING:
				from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_falcon import (
								    FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
								    FalconForCausalLM,
								    FalconForQuestionAnswering,
								    FalconForSequenceClassification,
								    FalconForTokenClassification,
								    FalconModel,
								    FalconPreTrainedModel,
								)


else:
				import sys

				UpperCAmelCase						:   List[str]			  =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




