


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	:     Any   =get_tests_dir("""fixtures""")
_UpperCAmelCase	:     List[Any]   =get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
_UpperCAmelCase	:     Optional[int]   =get_tests_dir("""fixtures/dummy-config.json""")







class  snake_case__(							unittest.TestCase							):







						'''simple docstring'''




						def   lowercase_       ( self							)    ->			Any:
										lowerCAmelCase_       :					List[str]			 = 0




						def   lowercase_       ( self							)    ->			Union[str, Any]:
										lowerCAmelCase_       :					List[Any]			 = AutoFeatureExtractor.from_pretrained('''facebook/wav2vec2-base-960h'''							)
										self.assertIsInstance(SCREAMING_SNAKE_CASE_      ,  SCREAMING_SNAKE_CASE_							)




						def   lowercase_       ( self							)    ->			Any:
										lowerCAmelCase_       :					Tuple			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							)
										self.assertIsInstance(SCREAMING_SNAKE_CASE_      ,  SCREAMING_SNAKE_CASE_							)




						def   lowercase_       ( self							)    ->			Optional[Any]:
										with tempfile.TemporaryDirectory() as tmpdirname:
														lowerCAmelCase_       :					List[str]			 = WavaVecaConfig()

														# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
														lowerCAmelCase_       :					Any			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							).to_dict()

														config_dict.pop('''feature_extractor_type'''							)
														lowerCAmelCase_       :					int			 = WavaVecaFeatureExtractor(**SCREAMING_SNAKE_CASE_							)

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

														lowerCAmelCase_       :					Optional[Any]			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							)

														# make sure private variable is not incorrectly saved
														lowerCAmelCase_       :					Union[str, Any]			 = json.loads(config.to_json_string()							)
														self.assertTrue('''_processor_class''' not in dict_as_saved							)

										self.assertIsInstance(SCREAMING_SNAKE_CASE_      ,  SCREAMING_SNAKE_CASE_							)




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					Dict			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							)
										self.assertIsInstance(SCREAMING_SNAKE_CASE_      ,  SCREAMING_SNAKE_CASE_							)




						def   lowercase_       ( self							)    ->			List[Any]:
										with self.assertRaisesRegex(
										    SCREAMING_SNAKE_CASE_      ,  '''bert-base is not a local folder and is not a valid model identifier'''							):
														lowerCAmelCase_       :					Union[str, Any]			 = AutoFeatureExtractor.from_pretrained('''bert-base'''							)




						def   lowercase_       ( self							)    ->			str:
										with self.assertRaisesRegex(
										    SCREAMING_SNAKE_CASE_      ,  R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''							):
														lowerCAmelCase_       :					Tuple			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_      ,  revision='''aaaaaa'''							)




						def   lowercase_       ( self							)    ->			Optional[int]:
										with self.assertRaisesRegex(
										    SCREAMING_SNAKE_CASE_      ,  '''hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'''      ,  ):
														lowerCAmelCase_       :					str			 = AutoFeatureExtractor.from_pretrained('''hf-internal-testing/config-no-model'''							)




						def   lowercase_       ( self							)    ->			Tuple:
										# If remote code is not set, we will time out when asking whether to load the model.
										with self.assertRaises(SCREAMING_SNAKE_CASE_							):
														lowerCAmelCase_       :					List[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(SCREAMING_SNAKE_CASE_							):
														lowerCAmelCase_       :					Any			 = AutoFeatureExtractor.from_pretrained(
														    '''hf-internal-testing/test_dynamic_feature_extractor'''      ,  trust_remote_code=SCREAMING_SNAKE_CASE_							)

										lowerCAmelCase_       :					Optional[Any]			 = AutoFeatureExtractor.from_pretrained(
										    '''hf-internal-testing/test_dynamic_feature_extractor'''      ,  trust_remote_code=SCREAMING_SNAKE_CASE_							)
										self.assertEqual(feature_extractor.__class__.__name__      ,  '''NewFeatureExtractor'''							)

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




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

														# Now that the config is registered, it can be used as any other config with the auto-API
														lowerCAmelCase_       :					str			 = CustomFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							)
														with tempfile.TemporaryDirectory() as tmp_dir:
																		feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE_							)
																		lowerCAmelCase_       :					str			 = AutoFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE_							)
																		self.assertIsInstance(SCREAMING_SNAKE_CASE_      ,  SCREAMING_SNAKE_CASE_							)

										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   lowercase_       ( self							)    ->			Dict:







										class  snake_case__(							UpperCAmelCase__							):







																'''simple docstring'''




																SCREAMING_SNAKE_CASE__					:     Optional[int]    =							True

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

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

import logging

from transformers.configuration_utils import PretrainedConfig


__a  			=					logging.getLogger(__name__)
class  lowercase__(				UpperCAmelCase							):



	"""simple docstring"""




	a			:Optional[int]         =	'masked_bert'
	def __init__(       self  :			Optional[int]       ,							SCREAMING_SNAKE_CASE_  :			List[Any]=3_0_5_2_2       ,							SCREAMING_SNAKE_CASE_  :			List[str]=7_6_8       ,							SCREAMING_SNAKE_CASE_  :			Optional[int]=1_2       ,							SCREAMING_SNAKE_CASE_  :			Any=1_2       ,							SCREAMING_SNAKE_CASE_  :			str=3_0_7_2       ,							SCREAMING_SNAKE_CASE_  :			Union[str, Any]="gelu"       ,							SCREAMING_SNAKE_CASE_  :			Optional[int]=0.1       ,							SCREAMING_SNAKE_CASE_  :			List[str]=0.1       ,							SCREAMING_SNAKE_CASE_  :			Tuple=5_1_2       ,							SCREAMING_SNAKE_CASE_  :			str=2       ,							SCREAMING_SNAKE_CASE_  :			Dict=0.02       ,							SCREAMING_SNAKE_CASE_  :			Any=1e-12       ,							SCREAMING_SNAKE_CASE_  :			Any=0       ,							SCREAMING_SNAKE_CASE_  :			Optional[int]="topK"       ,							SCREAMING_SNAKE_CASE_  :			Dict="constant"       ,							SCREAMING_SNAKE_CASE_  :			Optional[Any]=0.0       ,							**SCREAMING_SNAKE_CASE_  :			Optional[int]       ,							)       ->     Optional[Any]:
					super().__init__(pad_token_id=SCREAMING_SNAKE_CASE_       ,							**SCREAMING_SNAKE_CASE_       )

					lowercase_       =					vocab_size
					lowercase_       =					hidden_size
					lowercase_       =					num_hidden_layers
					lowercase_       =					num_attention_heads
					lowercase_       =					hidden_act
					lowercase_       =					intermediate_size
					lowercase_       =					hidden_dropout_prob
					lowercase_       =					attention_probs_dropout_prob
					lowercase_       =					max_position_embeddings
					lowercase_       =					type_vocab_size
					lowercase_       =					initializer_range
					lowercase_       =					layer_norm_eps
					lowercase_       =					pruning_method
					lowercase_       =					mask_init
					lowercase_       =					mask_scale




