



"""simple docstring"""


from ... import PretrainedConfig


snake_case_				     =       {
    """sijunhe/nezha-cn-base""": """https://huggingface.co/sijunhe/nezha-cn-base/resolve/main/config.json""",
}







class       A_			(     SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP
						__UpperCamelCase						=							"""nezha"""






						def __init__(					self :List[Any]   ,  lowercase_ :Optional[Any]=2_11_28   ,  lowercase_ :List[str]=7_68   ,  lowercase_ :List[str]=12   ,  lowercase_ :Dict=12   ,  lowercase_ :Tuple=30_72   ,  lowercase_ :Optional[int]="gelu"   ,  lowercase_ :Optional[Any]=0.1   ,  lowercase_ :List[Any]=0.1   ,  lowercase_ :List[Any]=5_12   ,  lowercase_ :Tuple=64   ,  lowercase_ :str=2   ,  lowercase_ :Optional[Any]=0.02   ,  lowercase_ :int=1E-12   ,  lowercase_ :Any=0.1   ,  lowercase_ :Optional[int]=0   ,  lowercase_ :Any=2   ,  lowercase_ :Dict=3   ,  lowercase_ :Any=True   ,  **lowercase_ :Tuple   ,  )				->			List[Any]:
												super().__init__(pad_token_id=lowercase_   ,  bos_token_id=lowercase_   ,  eos_token_id=lowercase_   ,  **lowercase_					)

												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








import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						return x + 2





class 	snake_case_   (		unittest.TestCase					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)

									snake_case_   =	'''x = y'''
									snake_case_   =	{'''y''': 5}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 5, '''y''': 5}							)







			def 				snake_case__(     self :				Dict							)      ->Optional[int]:
									snake_case_   =	'''y = add_two(x)'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)

									# Won't work without the tool
									with CaptureStdout() as out:
															snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result is None
									assert "tried to execute add_two" in out.out







			def 				snake_case__(     self :				Union[str, Any]							)      ->Dict:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Optional[int]:
									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Dict							)      ->str:
									snake_case_   =	'''x = 3\ny = 5'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	'''text = f\'This is x: {x}.\''''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == "This is x: 3."
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''text''': '''This is x: 3.'''}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->List[str]:
									snake_case_   =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 2}							)

									snake_case_   =	{'''x''': 8}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 8, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->str:
									snake_case_   =	'''test_list = [x, add_two(x)]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   [3, 5]							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)







			def 				snake_case__(     self :				Any							)      ->List[Any]:
									snake_case_   =	'''y = x'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Dict:
									snake_case_   =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)

									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 0\nfor i in range(3):\n    x = i'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''range''': range}							,   state=_UpperCamelCase							)
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 2, '''i''': 2}							)