




'''simple docstring'''


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


_snake_case   :   int     							=	get_tests_dir('fixtures')
_snake_case   :   List[Any]     							=	get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_snake_case   :   str     							=	get_tests_dir('fixtures/dummy-config.json')

class     A					(	unittest.TestCase					):







					def      __lowerCAmelCase    (						self :						int      )    ->							Dict:


												"""simple docstring"""


												_a			  =       0







					def      __lowerCAmelCase    (						self :						Union[str, Any]      )    ->							str:


												"""simple docstring"""


												_a			  =       AutoFeatureExtractor.from_pretrained('''facebook/wav2vec2-base-960h'''      )
												self.assertIsInstance(__a							,    __a      )







					def      __lowerCAmelCase    (						self :						Tuple      )    ->							List[str]:


												"""simple docstring"""


												_a			  =       AutoFeatureExtractor.from_pretrained(__a      )
												self.assertIsInstance(__a							,    __a      )







					def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Union[str, Any]:


												"""simple docstring"""


												with tempfile.TemporaryDirectory() as tmpdirname:
																			_a			  =       WavaVecaConfig()

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

																			config_dict.pop('''feature_extractor_type'''      )
																			_a			  =       WavaVecaFeatureExtractor(**__a      )

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

																			_a			  =       AutoFeatureExtractor.from_pretrained(__a      )

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

												self.assertIsInstance(__a							,    __a      )







					def      __lowerCAmelCase    (						self :						List[str]      )    ->							str:


												"""simple docstring"""


												_a			  =       AutoFeatureExtractor.from_pretrained(__a      )
												self.assertIsInstance(__a							,    __a      )







					def      __lowerCAmelCase    (						self :						Any      )    ->							Tuple:


												"""simple docstring"""


												with self.assertRaisesRegex(
												    __a							,    '''bert-base is not a local folder and is not a valid model identifier'''      ):
																			_a			  =       AutoFeatureExtractor.from_pretrained('''bert-base'''      )







					def      __lowerCAmelCase    (						self :						Optional[Any]      )    ->							int:


												"""simple docstring"""


												with self.assertRaisesRegex(
												    __a							,    R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''      ):
																			_a			  =       AutoFeatureExtractor.from_pretrained(__a							,    revision='''aaaaaa'''      )







					def      __lowerCAmelCase    (						self :						List[str]      )    ->							Tuple:


												"""simple docstring"""


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







					def      __lowerCAmelCase    (						self :						Union[str, Any]      )    ->							List[Any]:


												"""simple docstring"""


												with self.assertRaises(__a      ):
																			_a			  =       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			  =       AutoFeatureExtractor.from_pretrained(
																			    '''hf-internal-testing/test_dynamic_feature_extractor'''							,    trust_remote_code=__a      )

												_a			  =       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			  =       AutoFeatureExtractor.from_pretrained(__a							,    trust_remote_code=__a      )
												self.assertEqual(reloaded_feature_extractor.__class__.__name__							,    '''NewFeatureExtractor'''      )







					def      __lowerCAmelCase    (						self :						int      )    ->							Optional[Any]:


												"""simple docstring"""


												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			  =       CustomFeatureExtractor.from_pretrained(__a      )
																			with tempfile.TemporaryDirectory() as tmp_dir:
																										feature_extractor.save_pretrained(__a      )
																										_a			  =       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      __lowerCAmelCase    (						self :						int      )    ->							int:


												"""simple docstring"""


												class     A					(	__lowercase					):
																	lowercase_           =       True

												try:
																			AutoConfig.register('''custom'''							,    __a      )
																			AutoFeatureExtractor.register(__a							,    __a      )
																			# If remote code is not set, the default is to use local
																			_a			  =       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			  =       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			  =       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]







'''simple docstring'''


from ..utils import DummyObject, requires_backends

class     A					(	metaclass=_a					):
							lowercase_           =       ['torch', 'torchsde']







							def __init__(						self :						Optional[Any]							,    *lowerCAmelCase_ :						Any							,    **lowerCAmelCase_ :						Tuple      )    ->							Dict:


														"""simple docstring"""


														requires_backends(self							,    ['''torch''', '''torchsde''']      )







							@classmethod
							def      __lowerCAmelCase    (						cls :						Dict							,    *lowerCAmelCase_ :						Optional[int]							,    **lowerCAmelCase_ :						Optional[Any]      )    ->							int:


														"""simple docstring"""


														requires_backends(cls							,    ['''torch''', '''torchsde''']      )







							@classmethod
							def      __lowerCAmelCase    (						cls :						List[str]							,    *lowerCAmelCase_ :						str							,    **lowerCAmelCase_ :						Optional[Any]      )    ->							Any:


														"""simple docstring"""


														requires_backends(cls							,    ['''torch''', '''torchsde''']      )

