



"""simple docstring"""




import inspect
import os
import re

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
_UpperCamelCase: Tuple										=     '''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
_UpperCamelCase: Optional[int]										=     direct_transformers_import(PATH_TO_TRANSFORMERS)

_UpperCamelCase: Optional[Any]										=     transformers.models.auto.configuration_auto.CONFIG_MAPPING

_UpperCamelCase: List[Any]										=     {
    # used to compute the property `self.chunk_length`
    '''EncodecConfig''': ['''overlap'''],
    # used as `self.bert_model = BertModel(config, ...)`
    '''DPRConfig''': True,
    # not used in modeling files, but it's an important information
    '''FSMTConfig''': ['''langs'''],
    # used internally in the configuration class file
    '''GPTNeoConfig''': ['''attention_types'''],
    # used internally in the configuration class file
    '''EsmConfig''': ['''is_folding_model'''],
    # used during training (despite we don't have training script for these models yet)
    '''Mask2FormerConfig''': ['''ignore_value'''],
    # `ignore_value` used during training (despite we don't have training script for these models yet)
    # `norm` used in conversion script (despite not using in the modeling file)
    '''OneFormerConfig''': ['''ignore_value''', '''norm'''],
    # used during preprocessing and collation, see `collating_graphormer.py`
    '''GraphormerConfig''': ['''spatial_pos_max'''],
    # used internally in the configuration class file
    '''T5Config''': ['''feed_forward_proj'''],
    # used internally in the configuration class file
    # `tokenizer_class` get default value `T5Tokenizer` intentionally
    '''MT5Config''': ['''feed_forward_proj''', '''tokenizer_class'''],
    '''UMT5Config''': ['''feed_forward_proj''', '''tokenizer_class'''],
    # used internally in the configuration class file
    '''LongT5Config''': ['''feed_forward_proj'''],
    # used internally in the configuration class file
    '''SwitchTransformersConfig''': ['''feed_forward_proj'''],
    # having default values other than `1e-5` - we can't fix them without breaking
    '''BioGptConfig''': ['''layer_norm_eps'''],
    # having default values other than `1e-5` - we can't fix them without breaking
    '''GLPNConfig''': ['''layer_norm_eps'''],
    # having default values other than `1e-5` - we can't fix them without breaking
    '''SegformerConfig''': ['''layer_norm_eps'''],
    # having default values other than `1e-5` - we can't fix them without breaking
    '''CvtConfig''': ['''layer_norm_eps'''],
    # having default values other than `1e-5` - we can't fix them without breaking
    '''PerceiverConfig''': ['''layer_norm_eps'''],
    # used internally to calculate the feature size
    '''InformerConfig''': ['''num_static_real_features''', '''num_time_features'''],
    # used internally to calculate the feature size
    '''TimeSeriesTransformerConfig''': ['''num_static_real_features''', '''num_time_features'''],
    # used internally to calculate the feature size
    '''AutoformerConfig''': ['''num_static_real_features''', '''num_time_features'''],
    # used internally to calculate `mlp_dim`
    '''SamVisionConfig''': ['''mlp_ratio'''],
    # For (head) training, but so far not implemented
    '''ClapAudioConfig''': ['''num_classes'''],
    # Not used, but providing useful information to users
    '''SpeechT5HifiGanConfig''': ['''sampling_rate'''],
}


# TODO (ydshieh): Check the failing cases, try to fix them or move some cases to the above block once we are sure
SPECIAL_CASES_TO_ALLOW.update(
    {
        'CLIPSegConfig': True,
        'DeformableDetrConfig': True,
        'DetaConfig': True,
        'DinatConfig': True,
        'DonutSwinConfig': True,
        'EfficientFormerConfig': True,
        'FSMTConfig': True,
        'JukeboxConfig': True,
        'LayoutLMv2Config': True,
        'MaskFormerSwinConfig': True,
        'MT5Config': True,
        'NatConfig': True,
        'OneFormerConfig': True,
        'PerceiverConfig': True,
        'RagConfig': True,
        'SpeechT5Config': True,
        'SwinConfig': True,
        'Swin2SRConfig': True,
        'Swinv2Config': True,
        'SwitchTransformersConfig': True,
        'TableTransformerConfig': True,
        'TapasConfig': True,
        'TransfoXLConfig': True,
        'UniSpeechConfig': True,
        'UniSpeechSatConfig': True,
        'WavLMConfig': True,
        'WhisperConfig': True,
        # TODO: @Arthur (for `alignment_head` and `alignment_layer`)
        'JukeboxPriorConfig': True,
        # TODO: @Younes (for `is_decoder`)
        'Pix2StructTextConfig': True,
    }
)


def      lowercase__   (	_UpperCAmelCase		,					_UpperCAmelCase		,					_UpperCAmelCase		,					_UpperCAmelCase )   ->	Optional[int]:






      '''simple docstring'''


      lowercase     :					Optional[int] 		=      False
      for attribute in attributes:
            for modeling_source in source_strings:
                  # check if we can find `config.xxx`, `getattr(config, "xxx", ...)` or `getattr(self.config, "xxx", ...)`
                  if (
                      f'''config.{attribute}''' in modeling_source
                      or f'''getattr(config, \"{attribute}\"''' in modeling_source
                      or f'''getattr(self.config, \"{attribute}\"''' in modeling_source
                  ):
                        lowercase     :					Optional[int] 		=      True
                  # Deal with multi-line cases
                  elif (
                      re.search(
                          Rf'''getattr[ \t\v\n\r\f]*\([ \t\v\n\r\f]*(self\.)?config,[ \t\v\n\r\f]*\"{attribute}\"'''		,					__UpperCamelCase		,					)
                      is not None
                  ):
                        lowercase     :					Any 		=      True
                  # `SequenceSummary` is called with `SequenceSummary(config)`
                  elif attribute in [
                      "summary_type",
                      "summary_use_proj",
                      "summary_activation",
                      "summary_last_dropout",
                      "summary_proj_to_labels",
                      "summary_first_dropout",
                  ]:
                        if "SequenceSummary" in modeling_source:
                              lowercase     :					Union[str, Any] 		=      True
                  if attribute_used:
                        break
            if attribute_used:
                  break

    # common and important attributes, even if they do not always appear in the modeling files
      lowercase     :					int 		=      [
          '''bos_index''',
          '''eos_index''',
          '''pad_index''',
          '''unk_index''',
          '''mask_index''',
          '''image_size''',
          '''use_cache''',
          '''out_features''',
          '''out_indices''',
      ]
      lowercase     :					Optional[Any] 		=      ['''encoder_no_repeat_ngram_size''']

      # Special cases to be allowed
      lowercase     :					Union[str, Any] 		=      True
      if not attribute_used:
            lowercase     :					List[str] 		=      False
            for attribute in attributes:
                  # Allow if the default value in the configuration class is different from the one in `PretrainedConfig`
                  if attribute in ["is_encoder_decoder"] and default_value is True:
                        lowercase     :					List[str] 		=      True
                  elif attribute in ["tie_word_embeddings"] and default_value is False:
                        lowercase     :					List[str] 		=      True

                  # Allow cases without checking the default value in the configuration class
                  elif attribute in attributes_to_allow + attributes_used_in_generation:
                        lowercase     :					str 		=      True
                  elif attribute.endswith('_token_id' ):
                        lowercase     :					str 		=      True

                  # configuration class specific cases
                  if not case_allowed:
                        lowercase     :					int 		=      SPECIAL_CASES_TO_ALLOW.get(config_class.__name__		,					[] )
                        lowercase     :					List[Any] 		=      allowed_cases is True or attribute in allowed_cases

      return attribute_used or case_allowed


def      lowercase__   (	_UpperCAmelCase )   ->	int:






      '''simple docstring'''


      lowercase     :					Tuple 		=      dict(inspect.signature(config_class.__init__ ).parameters )
      lowercase     :					List[Any] 		=      [x for x in list(signature.keys() ) if x not in ['''self''', '''kwargs''']]
      lowercase     :					Any 		=      [signature[param].default for param in parameter_names]

      # If `attribute_map` exists, an attribute can have different names to be used in the modeling files, and as long
      # as one variant is used, the test should pass
      lowercase     :					Optional[int] 		=      {}
      if len(config_class.attribute_map ) > 0:
            lowercase     :					int 		=      {v: k for k, v in config_class.attribute_map.items()}

      # Get the path to modeling source files
      lowercase     :					Optional[int] 		=      inspect.getsourcefile(__UpperCamelCase )
      lowercase     :					Any 		=      os.path.dirname(__UpperCamelCase )
      # Let's check against all frameworks: as long as one framework uses an attribute, we are good.
      lowercase     :					Tuple 		=      [os.path.join(__UpperCamelCase		,					__UpperCamelCase ) for fn in os.listdir(__UpperCamelCase ) if fn.startswith('modeling_' )]

      # Get the source code strings
      lowercase     :					List[Any] 		=      []
      for path in modeling_paths:
            if os.path.isfile(__UpperCamelCase ):
                  with open(__UpperCamelCase ) as fp:
                        modeling_sources.append(fp.read() )

      lowercase     :					Dict 		=      []
      for config_param, default_value in zip(__UpperCamelCase		,					__UpperCamelCase ):
            # `attributes` here is all the variant names for `config_param`
            lowercase     :					Tuple 		=      [config_param]
            # some configuration classes have non-empty `attribute_map`, and both names could be used in the
            # corresponding modeling files. As long as one of them appears, it is fine.
            if config_param in reversed_attribute_map:
                  attributes.append(reversed_attribute_map[config_param] )

            if not check_attribute_being_used(__UpperCamelCase		,					__UpperCamelCase		,					__UpperCamelCase		,					__UpperCamelCase ):
                  unused_attributes.append(attributes[0] )

      return sorted(__UpperCamelCase )


def      lowercase__   (	)   ->	Optional[int]:






      '''simple docstring'''


      lowercase     :					Tuple 		=      {}
      for _config_class in list(CONFIG_MAPPING.values() ):
            # Skip deprecated models
            if "models.deprecated" in _config_class.__module__:
                  continue
            # Some config classes are not in `CONFIG_MAPPING` (e.g. `CLIPVisionConfig`, `Blip2VisionConfig`, etc.)
            lowercase     :					Union[str, Any] 		=      [
                cls
                for name, cls in inspect.getmembers(
                    inspect.getmodule(_config_class )		,					lambda _UpperCAmelCase : inspect.isclass(__UpperCamelCase )
                    and issubclass(__UpperCamelCase		,					__UpperCamelCase )
                    and inspect.getmodule(__UpperCamelCase ) == inspect.getmodule(_config_class )		,					)
            ]
            for config_class in config_classes_in_module:
                  lowercase     :					str 		=      check_config_attributes_being_used(__UpperCamelCase )
                  if len(__UpperCamelCase ) > 0:
                        lowercase     :					List[str] 		=      unused_attributes

      if len(__UpperCamelCase ) > 0:
            lowercase     :					Optional[Any] 		=      '''The following configuration classes contain unused attributes in the corresponding modeling files:\n'''
            for name, attributes in configs_with_unused_attributes.items():
                  error += f'''{name}: {attributes}\n'''

            raise ValueError(__UpperCamelCase )


if __name__ == "__main__":
     check_config_attributes()





from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A__  :  Union[str, Any]								=					logging.get_logger(__name__)

A__  :  Tuple								=					{
    '''facebook/xlm-roberta-xl''': '''https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json''',
    '''facebook/xlm-roberta-xxl''': '''https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json''',
    # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl
}



class 				__snake_case						(     UpperCamelCase_						):
							_a			      = '''xlm-roberta-xl'''




							def __init__(       self     :       int				,				A_     :       List[str]=2_5_0_8_8_0				,				A_     :       List[str]=2_5_6_0				,				A_     :       Optional[int]=3_6				,				A_     :       List[Any]=3_2				,				A_     :       Optional[int]=1_0_2_4_0				,				A_     :       Dict="gelu"				,				A_     :       int=0.1				,				A_     :       Optional[Any]=0.1				,				A_     :       int=5_1_4				,				A_     :       Any=1				,				A_     :       Optional[Any]=0.02				,				A_     :       str=1e-05				,				A_     :       Dict=1				,				A_     :       Any=0				,				A_     :       Tuple=2				,				A_     :       str="absolute"				,				A_     :       str=True				,				A_     :       List[str]=None				,				**A_     :       Dict				,				):
									super().__init__(pad_token_id=A_				,				bos_token_id=A_				,				eos_token_id=A_				,				**A_)
									lowerCAmelCase_			:     Tuple									= vocab_size
									lowerCAmelCase_			:     List[str]									= hidden_size
									lowerCAmelCase_			:     int									= num_hidden_layers
									lowerCAmelCase_			:     int									= num_attention_heads
									lowerCAmelCase_			:     Dict									= hidden_act
									lowerCAmelCase_			:     int									= intermediate_size
									lowerCAmelCase_			:     Tuple									= hidden_dropout_prob
									lowerCAmelCase_			:     Optional[Any]									= attention_probs_dropout_prob
									lowerCAmelCase_			:     Union[str, Any]									= max_position_embeddings
									lowerCAmelCase_			:     Dict									= type_vocab_size
									lowerCAmelCase_			:     str									= initializer_range
									lowerCAmelCase_			:     str									= layer_norm_eps
									lowerCAmelCase_			:     Optional[Any]									= position_embedding_type
									lowerCAmelCase_			:     Optional[Any]									= use_cache
									lowerCAmelCase_			:     List[str]									= classifier_dropout





class 				__snake_case						(     UpperCamelCase_						):




							@property
							def    UpperCAmelCase__			(       self     :       List[str]):
									if self.task == "multiple-choice":
											lowerCAmelCase_			:     Union[str, Any]									= {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
									else:
											lowerCAmelCase_			:     List[Any]									= {0: '''batch''', 1: '''sequence'''}
									return OrderedDict(
									    [
									        ('''input_ids''', dynamic_axis),
									        ('''attention_mask''', dynamic_axis),
									    ])





