





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs



class 					__lowerCAmelCase       (			__SCREAMING_SNAKE_CASE     ):






			def __init__(self					,							__magic_name__					,							__magic_name__=None					,							__magic_name__=True					,							__magic_name__=None					,							**__magic_name__    )     ->   Optional[int]:


							'''simple docstring'''



							snake_case_						:    Any				=  parent
							snake_case_						:    int				=  config_class
							snake_case_						:    List[str]				=  has_text_modality
							snake_case_						:    str				=  kwargs
							snake_case_						:    Any				=  common_properties






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


							'''simple docstring'''



							snake_case_						:    str				=  self.config_class(**self.inputs_dict    )
							snake_case_						:    int				=  (
							    ["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(UpperCAmelCase_					,							UpperCAmelCase_    )					,							msg=F'''`{prop}` does not exist'''    )

							# Test that config has the common properties as setter
							for idx, name in enumerate(UpperCAmelCase_    ):
											try:
															setattr(UpperCAmelCase_					,							UpperCAmelCase_					,							UpperCAmelCase_    )
															self.parent.assertEqual(
															    getattr(UpperCAmelCase_					,							UpperCAmelCase_    )					,							UpperCAmelCase_					,							msg=F'''`{name} value {idx} expected, but was {getattr(UpperCAmelCase_					,							UpperCAmelCase_    )}'''    )
											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(UpperCAmelCase_    ):
											try:
															snake_case_						:    Optional[int]				=  self.config_class(**{name: idx}    )
															self.parent.assertEqual(
															    getattr(UpperCAmelCase_					,							UpperCAmelCase_    )					,							UpperCAmelCase_					,							msg=F'''`{name} value {idx} expected, but was {getattr(UpperCAmelCase_					,							UpperCAmelCase_    )}'''    )
											except NotImplementedError:
															# Some models might not be able to implement setters for common_properties
															# In that case, a NotImplementedError is raised
															pass






			def 			lowerCamelCase  (self    )     ->   Optional[int]:


							'''simple docstring'''



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






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  self.config_class(**self.inputs_dict    )

							with tempfile.TemporaryDirectory() as tmpdirname:
											snake_case_						:    List[str]				=  os.path.join(UpperCAmelCase_					,							'''config.json'''    )
											config_first.to_json_file(UpperCAmelCase_    )
											snake_case_						:    Tuple				=  self.config_class.from_json_file(UpperCAmelCase_    )

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






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  self.config_class(**self.inputs_dict    )

							with tempfile.TemporaryDirectory() as tmpdirname:
											config_first.save_pretrained(UpperCAmelCase_    )
											snake_case_						:    Any				=  self.config_class.from_pretrained(UpperCAmelCase_    )

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






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


							'''simple docstring'''



							snake_case_						:    Tuple				=  self.config_class(**self.inputs_dict    )

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

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






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


							'''simple docstring'''



							snake_case_						:    Dict				=  self.config_class(**self.inputs_dict					,							num_labels=5    )
							self.parent.assertEqual(len(config.idalabel    )					,							5    )
							self.parent.assertEqual(len(config.labelaid    )					,							5    )

							snake_case_						:    Any				=  3
							self.parent.assertEqual(len(config.idalabel    )					,							3    )
							self.parent.assertEqual(len(config.labelaid    )					,							3    )






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							if self.config_class.is_composition:
											return
							snake_case_						:    Tuple				=  self.config_class()
							self.parent.assertIsNotNone(UpperCAmelCase_    )






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


							'''simple docstring'''



							snake_case_						:    Dict				=  copy.deepcopy(UpperCAmelCase_    )
							snake_case_						:    str				=  self.config_class(**UpperCAmelCase_    )
							snake_case_						:    Optional[int]				=  []
							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(UpperCAmelCase_					,							UpperCAmelCase_    ) != value:
															wrong_values.append((key, getattr(UpperCAmelCase_					,							UpperCAmelCase_    ), value)    )

							if len(UpperCAmelCase_    ) > 0:
											snake_case_						:    List[Any]				=  "\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 			lowerCamelCase  (self    )     ->   Tuple:


							'''simple docstring'''



							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()







import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
__A									=				"."


if __name__ == "__main__":
     __A									=				os.path.join(REPO_PATH, "utils/documentation_tests.txt")
     __A									=				[]
     __A									=				[]
     with open(doctest_file_path) as fp:
          for line in fp:
               __A									=				line.strip()
               __A									=				os.path.join(REPO_PATH, line)
               if not (os.path.isfile(path) or os.path.isdir(path)):
                    non_existent_paths.append(line)
               all_paths.append(path)
     if len(non_existent_paths) > 0:
          __A									=				"\n".join(non_existent_paths)
          raise ValueError(f'`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}')
     if all_paths != sorted(all_paths):
          raise ValueError("Files in `utils/documentation_tests.txt` are not in alphabetical order.")

