"""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 					lowerCAmelCase_      (     lowerCAmelCase   ):



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=None						,      lowerCAmelCase=True						,      lowerCAmelCase=None						,      **lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     parent
										snake_case        =     config_class
										snake_case        =     has_text_modality
										snake_case        =     kwargs
										snake_case        =     common_properties

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										with tempfile.TemporaryDirectory() as tmpdirname:
																snake_case        =     os.path.join(lowerCAmelCase						,      'config.json'      )
																config_first.to_json_file(lowerCAmelCase      )
																snake_case        =     self.config_class.from_json_file(lowerCAmelCase      )

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										with tempfile.TemporaryDirectory() as tmpdirname:
																config_first.save_pretrained(lowerCAmelCase      )
																snake_case        =     self.config_class.from_pretrained(lowerCAmelCase      )

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										snake_case        =     'test'
										with tempfile.TemporaryDirectory() as tmpdirname:
																snake_case        =     os.path.join(lowerCAmelCase						,      lowerCAmelCase      )
																config_first.save_pretrained(lowerCAmelCase      )
																snake_case        =     self.config_class.from_pretrained(lowerCAmelCase						,      subfolder=lowerCAmelCase      )

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     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        =     3
										self.parent.assertEqual(len(config.idalabel      )						,      3      )
										self.parent.assertEqual(len(config.labelaid      )						,      3      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										if self.config_class.is_composition:
																return
										snake_case        =     self.config_class()
										self.parent.assertIsNotNone(lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     copy.deepcopy(lowerCAmelCase      )
										snake_case        =     self.config_class(**lowerCAmelCase      )
										snake_case        =     []
										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(lowerCAmelCase						,      lowerCAmelCase      ) != value:
																						wrong_values.append((key, getattr(lowerCAmelCase						,      lowerCAmelCase      ), value)      )

										if len(lowerCAmelCase      ) > 0:
																snake_case        =     '\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 						snake_case	(			self      ):






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




"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE__   =					{
    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig", "XLMOnnxConfig"],
    "tokenization_xlm": ["XLMTokenizer"],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__   =					[
					    "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "XLMForMultipleChoice",
					    "XLMForQuestionAnswering",
					    "XLMForQuestionAnsweringSimple",
					    "XLMForSequenceClassification",
					    "XLMForTokenClassification",
					    "XLMModel",
					    "XLMPreTrainedModel",
					    "XLMWithLMHeadModel",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__   =					[
					    "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TFXLMForMultipleChoice",
					    "TFXLMForQuestionAnsweringSimple",
					    "TFXLMForSequenceClassification",
					    "TFXLMForTokenClassification",
					    "TFXLMMainLayer",
					    "TFXLMModel",
					    "TFXLMPreTrainedModel",
					    "TFXLMWithLMHeadModel",
					]


if TYPE_CHECKING:
					from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
					from .tokenization_xlm import XLMTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm import (
										    XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMForMultipleChoice,
										    XLMForQuestionAnswering,
										    XLMForQuestionAnsweringSimple,
										    XLMForSequenceClassification,
										    XLMForTokenClassification,
										    XLMModel,
										    XLMPreTrainedModel,
										    XLMWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_xlm import (
										    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFXLMForMultipleChoice,
										    TFXLMForQuestionAnsweringSimple,
										    TFXLMForSequenceClassification,
										    TFXLMForTokenClassification,
										    TFXLMMainLayer,
										    TFXLMModel,
										    TFXLMPreTrainedModel,
										    TFXLMWithLMHeadModel,
										)

else:
					import sys

					SCREAMING_SNAKE_CASE__   =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


