





from ... import PretrainedConfig


__lowercase	: List[str]       ={
    """sijunhe/nezha-cn-base""": """https://huggingface.co/sijunhe/nezha-cn-base/resolve/main/config.json""",
}

class   A							(						__lowercase    ):
      _snake_case				  =NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP
      _snake_case				  ='''nezha'''



      def __init__(						self:    Union[str, Any]		,	_lowerCAmelCase:    Tuple=2_1128		,	_lowerCAmelCase:    Dict=768		,	_lowerCAmelCase:    Optional[int]=12		,	_lowerCAmelCase:    Union[str, Any]=12		,	_lowerCAmelCase:    List[str]=3072		,	_lowerCAmelCase:    Any="gelu"		,	_lowerCAmelCase:    str=0.1		,	_lowerCAmelCase:    Any=0.1		,	_lowerCAmelCase:    int=512		,	_lowerCAmelCase:    Tuple=64		,	_lowerCAmelCase:    List[Any]=2		,	_lowerCAmelCase:    Any=0.02		,	_lowerCAmelCase:    List[str]=1e-12		,	_lowerCAmelCase:    List[Any]=0.1		,	_lowerCAmelCase:    Dict=0		,	_lowerCAmelCase:    List[Any]=2		,	_lowerCAmelCase:    Optional[Any]=3		,	_lowerCAmelCase:    Dict=True		,	**_lowerCAmelCase:    List[Any]		,	)    ->     Tuple:
         '''simple docstring'''

         super().__init__(pad_token_id=_lowerCAmelCase		,	bos_token_id=_lowerCAmelCase		,	eos_token_id=_lowerCAmelCase		,	**_lowerCAmelCase							)

         UpperCAmelCase_           =vocab_size
         UpperCAmelCase_           =hidden_size
         UpperCAmelCase_           =num_hidden_layers
         UpperCAmelCase_           =num_attention_heads
         UpperCAmelCase_           =hidden_act
         UpperCAmelCase_           =intermediate_size
         UpperCAmelCase_           =hidden_dropout_prob
         UpperCAmelCase_           =attention_probs_dropout_prob
         UpperCAmelCase_           =max_position_embeddings
         UpperCAmelCase_           =max_relative_position
         UpperCAmelCase_           =type_vocab_size
         UpperCAmelCase_           =initializer_range
         UpperCAmelCase_           =layer_norm_eps
         UpperCAmelCase_           =classifier_dropout
         UpperCAmelCase_           =use_cache






from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching




def 	UpperCamelCase__  (     )  ->     List[str]:
						import os as original_os
						from os import path as original_path
						from os import rename as original_rename
						from os.path import dirname as original_dirname
						from os.path import join as original_join

						assert _test_patching.os is original_os
						assert _test_patching.path is original_path
						assert _test_patching.join is original_join

						assert _test_patching.renamed_os is original_os
						assert _test_patching.renamed_path is original_path
						assert _test_patching.renamed_join is original_join

						_lowercase					       =					"""__test_patch_submodule_mock__"""
						with patch_submodule(_test_patching		,   """os.path.join"""		,   SCREAMING_SNAKE_CASE_       ):
												# Every way to access os.path.join must be patched, and the rest must stay untouched

												# check os.path.join
												assert isinstance(_test_patching.os		,   _PatchedModuleObj       )
												assert isinstance(_test_patching.os.path		,   _PatchedModuleObj       )
												assert _test_patching.os.path.join is mock

												# check path.join
												assert isinstance(_test_patching.path		,   _PatchedModuleObj       )
												assert _test_patching.path.join is mock

												# check join
												assert _test_patching.join is mock

												# check that the other attributes are untouched
												assert _test_patching.os.rename is original_rename
												assert _test_patching.path.dirname is original_dirname
												assert _test_patching.os.path.dirname is original_dirname

												# Even renamed modules or objects must be patched

												# check renamed_os.path.join
												assert isinstance(_test_patching.renamed_os		,   _PatchedModuleObj       )
												assert isinstance(_test_patching.renamed_os.path		,   _PatchedModuleObj       )
												assert _test_patching.renamed_os.path.join is mock

												# check renamed_path.join
												assert isinstance(_test_patching.renamed_path		,   _PatchedModuleObj       )
												assert _test_patching.renamed_path.join is mock

												# check renamed_join
												assert _test_patching.renamed_join is mock

												# check that the other attributes are untouched
												assert _test_patching.renamed_os.rename is original_rename
												assert _test_patching.renamed_path.dirname is original_dirname
												assert _test_patching.renamed_os.path.dirname is original_dirname

						# check that everthing is back to normal when the patch is over

						assert _test_patching.os is original_os
						assert _test_patching.path is original_path
						assert _test_patching.join is original_join

						assert _test_patching.renamed_os is original_os
						assert _test_patching.renamed_path is original_path
						assert _test_patching.renamed_join is original_join




def 	UpperCamelCase__  (     )  ->     int:
						assert _test_patching.open is open

						_lowercase					       =					"""__test_patch_submodule_builtin_mock__"""
						# _test_patching has "open" in its globals
						assert _test_patching.open is open
						with patch_submodule(_test_patching		,   """open"""		,   SCREAMING_SNAKE_CASE_       ):
												assert _test_patching.open is mock

						# check that everthing is back to normal when the patch is over

						assert _test_patching.open is open




def 	UpperCamelCase__  (     )  ->     List[Any]:
						# pandas.read_csv is not present in _test_patching
						_lowercase					       =					"""__test_patch_submodule_missing_mock__"""
						with patch_submodule(_test_patching		,   """pandas.read_csv"""		,   SCREAMING_SNAKE_CASE_       ):
												pass




def 	UpperCamelCase__  (     )  ->     Tuple:
						# builtin should always be mocked even if they're not in the globals
						# in case they're loaded at one point
						_lowercase					       =					"""__test_patch_submodule_missing_builtin_mock__"""
						# _test_patching doesn't have "len" in its globals
						assert getattr(_test_patching		,   """len"""		,   SCREAMING_SNAKE_CASE_       ) is None
						with patch_submodule(_test_patching		,   """len"""		,   SCREAMING_SNAKE_CASE_       ):
												assert _test_patching.len is mock
						assert _test_patching.len is len




def 	UpperCamelCase__  (     )  ->     List[str]:
						_lowercase					       =					"""__test_patch_submodule_start_and_stop_mock__"""
						_lowercase					       =					patch_submodule(_test_patching		,   """open"""		,   SCREAMING_SNAKE_CASE_       )
						assert _test_patching.open is open
						patch.start()
						assert _test_patching.open is mock
						patch.stop()
						assert _test_patching.open is open




def 	UpperCamelCase__  (     )  ->     Union[str, Any]:
						from os import rename as original_rename
						from os.path import dirname as original_dirname
						from os.path import join as original_join

						_lowercase					       =					"""__test_patch_submodule_successive_join__"""
						_lowercase					       =					"""__test_patch_submodule_successive_dirname__"""
						_lowercase					       =					"""__test_patch_submodule_successive_rename__"""
						assert _test_patching.os.path.join is original_join
						assert _test_patching.os.path.dirname is original_dirname
						assert _test_patching.os.rename is original_rename

						with patch_submodule(_test_patching		,   """os.path.join"""		,   SCREAMING_SNAKE_CASE_       ):
												with patch_submodule(_test_patching		,   """os.rename"""		,   SCREAMING_SNAKE_CASE_       ):
																		with patch_submodule(_test_patching		,   """os.path.dirname"""		,   SCREAMING_SNAKE_CASE_       ):
																								assert _test_patching.os.path.join is mock_join
																								assert _test_patching.os.path.dirname is mock_dirname
																								assert _test_patching.os.rename is mock_rename

    # try another order
						with patch_submodule(_test_patching		,   """os.rename"""		,   SCREAMING_SNAKE_CASE_       ):
												with patch_submodule(_test_patching		,   """os.path.join"""		,   SCREAMING_SNAKE_CASE_       ):
																		with patch_submodule(_test_patching		,   """os.path.dirname"""		,   SCREAMING_SNAKE_CASE_       ):
																								assert _test_patching.os.path.join is mock_join
																								assert _test_patching.os.path.dirname is mock_dirname
																								assert _test_patching.os.rename is mock_rename

						assert _test_patching.os.path.join is original_join
						assert _test_patching.os.path.dirname is original_dirname
						assert _test_patching.os.rename is original_rename




def 	UpperCamelCase__  (     )  ->     List[Any]:
						_lowercase					       =					"""__test_patch_submodule_doesnt_exist_mock__"""
						with patch_submodule(_test_patching		,   """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""		,   SCREAMING_SNAKE_CASE_       ):
												pass
						with patch_submodule(_test_patching		,   """os.__attribute_that_doesn_exist__"""		,   SCREAMING_SNAKE_CASE_       ):
												pass