



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


lowercase_								=     get_tests_dir("""fixtures""")
lowercase_								=     get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
lowercase_								=     get_tests_dir("""fixtures/dummy-config.json""")
class 				_snake_case			(					unittest.TestCase):




				def 							A__      (						self					:						int						):
							lowercase__					  =				0




				def 							A__      (						self					:						Any						):
							lowercase__					  =				AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h"						)
							self.assertIsInstance(__lowercase,					__lowercase						)




				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				AutoFeatureExtractor.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase,					__lowercase						)




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

										# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
										lowercase__					  =				AutoFeatureExtractor.from_pretrained(__lowercase						).to_dict()

										config_dict.pop("feature_extractor_type"						)
										lowercase__					  =				WavaVecaFeatureExtractor(**__lowercase						)

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

										lowercase__					  =				AutoFeatureExtractor.from_pretrained(__lowercase						)

										# make sure private variable is not incorrectly saved
										lowercase__					  =				json.loads(config.to_json_string()						)
										self.assertTrue("_processor_class" not in dict_as_saved						)

							self.assertIsInstance(__lowercase,					__lowercase						)




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				AutoFeatureExtractor.from_pretrained(__lowercase						)
							self.assertIsInstance(__lowercase,					__lowercase						)




				def 							A__      (						self					:						Optional[int]						):
							with self.assertRaisesRegex(
							    __lowercase,					"bert-base is not a local folder and is not a valid model identifier"						):
										lowercase__					  =				AutoFeatureExtractor.from_pretrained("bert-base"						)




				def 							A__      (						self					:						int						):
							with self.assertRaisesRegex(
							    __lowercase,					R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"						):
										lowercase__					  =				AutoFeatureExtractor.from_pretrained(__lowercase,					revision="aaaaaa"						)




				def 							A__      (						self					:						Tuple						):
							with self.assertRaisesRegex(
							    __lowercase,					"hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.",					):
										lowercase__					  =				AutoFeatureExtractor.from_pretrained("hf-internal-testing/config-no-model"						)




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

							lowercase__					  =				AutoFeatureExtractor.from_pretrained(
							    "hf-internal-testing/test_dynamic_feature_extractor",					trust_remote_code=__lowercase						)
							self.assertEqual(feature_extractor.__class__.__name__,					"NewFeatureExtractor"						)

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




				def 							A__      (						self					:						List[Any]						):
							try:
										AutoConfig.register("custom",					__lowercase						)
										AutoFeatureExtractor.register(__lowercase,					__lowercase						)
										# Trying to register something existing in the Transformers library will raise an error
										with self.assertRaises(__lowercase						):
													AutoFeatureExtractor.register(__lowercase,					__lowercase						)

										# Now that the config is registered, it can be used as any other config with the auto-API
										lowercase__					  =				CustomFeatureExtractor.from_pretrained(__lowercase						)
										with tempfile.TemporaryDirectory() as tmp_dir:
													feature_extractor.save_pretrained(__lowercase						)
													lowercase__					  =				AutoFeatureExtractor.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]




				def 							A__      (						self					:						Union[str, Any]						):
							class 				_snake_case			(					lowercase__):
											UpperCamelCase__				:					List[str]     		=True

							try:
										AutoConfig.register("custom",					__lowercase						)
										AutoFeatureExtractor.register(__lowercase,					__lowercase						)
										# If remote code is not set, the default is to use local
										lowercase__					  =				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.
										lowercase__					  =				AutoFeatureExtractor.from_pretrained(
										    "hf-internal-testing/test_dynamic_feature_extractor",					trust_remote_code=__lowercase						)
										self.assertEqual(feature_extractor.__class__.__name__,					"NewFeatureExtractor"						)
										self.assertTrue(feature_extractor.is_local						)

										# If remote is enabled, we load from the Hub
										lowercase__					  =				AutoFeatureExtractor.from_pretrained(
										    "hf-internal-testing/test_dynamic_feature_extractor",					trust_remote_code=__lowercase						)
										self.assertEqual(feature_extractor.__class__.__name__,					"NewFeatureExtractor"						)
										self.assertTrue(not hasattr(__lowercase,					"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]









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_								=     {
    """configuration_xmod""": [
        """XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XmodConfig""",
        """XmodOnnxConfig""",
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_								=     [
							    """XMOD_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """XmodForCausalLM""",
							    """XmodForMaskedLM""",
							    """XmodForMultipleChoice""",
							    """XmodForQuestionAnswering""",
							    """XmodForSequenceClassification""",
							    """XmodForTokenClassification""",
							    """XmodModel""",
							    """XmodPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xmod import (
														    XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XmodForCausalLM,
														    XmodForMaskedLM,
														    XmodForMultipleChoice,
														    XmodForQuestionAnswering,
														    XmodForSequenceClassification,
														    XmodForTokenClassification,
														    XmodModel,
														    XmodPreTrainedModel,
														)

else:
							import sys

							lowercase_								=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




