





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs



class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''

 def __init__(self				:   Dict       , UpperCAmelCase_				:   List[str]       , UpperCAmelCase_				:   Tuple=None       , UpperCAmelCase_				:   int=True       , UpperCAmelCase_				:   int=None       , **UpperCAmelCase_				:   List[str])       ->Optional[int]:



   '''simple docstring'''



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

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int])       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      str			  =self.config_class(**self.inputs_dict)
   lowerCamelCase__:      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:
       lowerCamelCase__:      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 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->Optional[int]:



   '''simple docstring'''



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

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



   '''simple docstring'''



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

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

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

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



   '''simple docstring'''



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

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

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

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int])       ->List[str]:



   '''simple docstring'''



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

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

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

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



   '''simple docstring'''



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

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

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->int:



   '''simple docstring'''



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

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



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =copy.deepcopy(UpperCAmelCase_)
   lowerCamelCase__:      str			  =self.config_class(**UpperCAmelCase_)
   lowerCamelCase__:      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:
     lowerCamelCase__:      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 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->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()



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A				={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A				=['''XGLMTokenizer''']

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A				=['''XGLMTokenizerFast''']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A				=[
			    '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''XGLMForCausalLM''',
			    '''XGLMModel''',
			    '''XGLMPreTrainedModel''',
			]


try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A				=[
			    '''FlaxXGLMForCausalLM''',
			    '''FlaxXGLMModel''',
			    '''FlaxXGLMPreTrainedModel''',
			]


try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A				=[
			    '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFXGLMForCausalLM''',
			    '''TFXGLMModel''',
			    '''TFXGLMPreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_xglm import XGLMTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_xglm_fast import XGLMTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_xglm import (
						    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFXGLMForCausalLM,
						    TFXGLMModel,
						    TFXGLMPreTrainedModel,
						)


else:
			import sys

			__A				=_LazyModule(__name__, globals()['''__file__'''], _import_structure)


