


'''simple docstring'''


import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs





class        lowercase__    (		_snake_case   ):





							'''simple docstring'''


							def __init__(       self       ,   __snake_case       ,   __snake_case=None       ,   __snake_case=True       ,   __snake_case=None       ,   **__snake_case    ):
											_SCREAMING_SNAKE_CASE					:			str							= parent
											_SCREAMING_SNAKE_CASE					:			int							= config_class
											_SCREAMING_SNAKE_CASE					:			int							= has_text_modality
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= kwargs
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= common_properties






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Dict							= self.config_class(**self.inputs_dict    )
											_SCREAMING_SNAKE_CASE					:			List[str]							= (
											    ["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""]
											    if self.common_properties is None
											    else self.common_properties
											)

											# Add common fields for text models
											if self.has_text_modality:
															common_properties.extend(["""vocab_size"""]    )

											# Test that config has the common properties as getters
											for prop in common_properties:
															self.parent.assertTrue(hasattr(__snake_case       ,   __snake_case    )       ,   msg=f"""`{prop}` does not exist"""    )

											# Test that config has the common properties as setter
											for idx, name in enumerate(__snake_case    ):
															try:
																			setattr(__snake_case       ,   __snake_case       ,   __snake_case    )
																			self.parent.assertEqual(
																			    getattr(__snake_case       ,   __snake_case    )       ,   __snake_case       ,   msg=f"""`{name} value {idx} expected, but was {getattr(__snake_case       ,   __snake_case    )}"""    )
															except NotImplementedError:
																			# Some models might not be able to implement setters for common_properties
																			# In that case, a NotImplementedError is raised
																			pass

        # Test if config class can be called with Config(prop_name=..)
											for idx, name in enumerate(__snake_case    ):
															try:
																			_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self.config_class(**{name: idx}    )
																			self.parent.assertEqual(
																			    getattr(__snake_case       ,   __snake_case    )       ,   __snake_case       ,   msg=f"""`{name} value {idx} expected, but was {getattr(__snake_case       ,   __snake_case    )}"""    )
															except NotImplementedError:
																			# Some models might not be able to implement setters for common_properties
																			# In that case, a NotImplementedError is raised
																			pass






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			List[str]							= self.config_class(**self.inputs_dict    )
											_SCREAMING_SNAKE_CASE					:			Dict							= json.loads(config.to_json_string()    )
											for key, value in self.inputs_dict.items():
															self.parent.assertEqual(obj[key]       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= self.config_class(**self.inputs_dict    )

											with tempfile.TemporaryDirectory() as tmpdirname:
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= os.path.join(__snake_case       ,   """config.json"""    )
															config_first.to_json_file(__snake_case    )
															_SCREAMING_SNAKE_CASE					:			str							= self.config_class.from_json_file(__snake_case    )

											self.parent.assertEqual(config_second.to_dict()       ,   config_first.to_dict()    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.config_class(**self.inputs_dict    )

											with tempfile.TemporaryDirectory() as tmpdirname:
															config_first.save_pretrained(__snake_case    )
															_SCREAMING_SNAKE_CASE					:			List[Any]							= self.config_class.from_pretrained(__snake_case    )

											self.parent.assertEqual(config_second.to_dict()       ,   config_first.to_dict()    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self.config_class(**self.inputs_dict    )

											_SCREAMING_SNAKE_CASE					:			List[Any]							= """test"""
											with tempfile.TemporaryDirectory() as tmpdirname:
															_SCREAMING_SNAKE_CASE					:			Any							= os.path.join(__snake_case       ,   __snake_case    )
															config_first.save_pretrained(__snake_case    )
															_SCREAMING_SNAKE_CASE					:			str							= self.config_class.from_pretrained(__snake_case       ,   subfolder=__snake_case    )

											self.parent.assertEqual(config_second.to_dict()       ,   config_first.to_dict()    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			List[str]							= self.config_class(**self.inputs_dict       ,   num_labels=5    )
											self.parent.assertEqual(len(config.idalabel    )       ,   5    )
											self.parent.assertEqual(len(config.labelaid    )       ,   5    )

											_SCREAMING_SNAKE_CASE					:			str							= 3
											self.parent.assertEqual(len(config.idalabel    )       ,   3    )
											self.parent.assertEqual(len(config.labelaid    )       ,   3    )






							def UpperCAmelCase_      (       self    ):
											if self.config_class.is_composition:
															return
											_SCREAMING_SNAKE_CASE					:			List[Any]							= self.config_class()
											self.parent.assertIsNotNone(__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= copy.deepcopy(__snake_case    )
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.config_class(**__snake_case    )
											_SCREAMING_SNAKE_CASE					:			List[Any]							= []
											for key, value in config_common_kwargs.items():
															if key == "torch_dtype":
																			if not is_torch_available():
																							continue
																			else:
																							import torch

																							if config.torch_dtype != torch.floataa:
																											wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa)    )
															elif getattr(__snake_case       ,   __snake_case    ) != value:
																			wrong_values.append((key, getattr(__snake_case       ,   __snake_case    ), value)    )

											if len(__snake_case    ) > 0:
															_SCREAMING_SNAKE_CASE					:			List[str]							= """\n""".join([f"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]    )
															raise ValueError(f"""The following keys were not properly set in the config:\n{errors}"""    )






							def UpperCAmelCase_      (       self    ):
											self.create_and_test_config_common_properties()
											self.create_and_test_config_to_json_string()
											self.create_and_test_config_to_json_file()
											self.create_and_test_config_from_and_save_pretrained()
											self.create_and_test_config_from_and_save_pretrained_subfolder()
											self.create_and_test_config_with_num_labels()
											self.check_config_can_be_init_without_params()
											self.check_config_arguments_init()








'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_						:  str				  =						logging.get_logger(__name__)

UpperCAmelCase_						:  Optional[int]				  =						{
    'SCUT-DLVCLab/lilt-roberta-en-base': (
        'https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json'
    ),
}





class        lowercase__    (		_snake_case   ):





							'''simple docstring'''


							A_				: List[str]       =    """lilt"""






							def __init__(       self       ,   __snake_case=3_0522       ,   __snake_case=768       ,   __snake_case=12       ,   __snake_case=12       ,   __snake_case=3072       ,   __snake_case="gelu"       ,   __snake_case=0.1       ,   __snake_case=0.1       ,   __snake_case=512       ,   __snake_case=2       ,   __snake_case=0.02       ,   __snake_case=1e-12       ,   __snake_case=0       ,   __snake_case="absolute"       ,   __snake_case=None       ,   __snake_case=4       ,   __snake_case=1024       ,   **__snake_case       ,   ):
											super().__init__(pad_token_id=__snake_case       ,   **__snake_case    )

											_SCREAMING_SNAKE_CASE					:			str							= vocab_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= hidden_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= num_hidden_layers
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= num_attention_heads
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= hidden_act
											_SCREAMING_SNAKE_CASE					:			Dict							= intermediate_size
											_SCREAMING_SNAKE_CASE					:			Tuple							= hidden_dropout_prob
											_SCREAMING_SNAKE_CASE					:			List[str]							= attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= max_position_embeddings
											_SCREAMING_SNAKE_CASE					:			Dict							= type_vocab_size
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= initializer_range
											_SCREAMING_SNAKE_CASE					:			Tuple							= layer_norm_eps
											_SCREAMING_SNAKE_CASE					:			str							= position_embedding_type
											_SCREAMING_SNAKE_CASE					:			List[str]							= classifier_dropout
											_SCREAMING_SNAKE_CASE					:			int							= channel_shrink_ratio
											_SCREAMING_SNAKE_CASE					:			str							= max_ad_position_embeddings




