






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								=		'''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
UpperCamelCase								=		direct_transformers_import(PATH_TO_TRANSFORMERS)

UpperCamelCase								=		transformers.models.auto.configuration_auto.CONFIG_MAPPING

UpperCamelCase								=		{
    # 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    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    List[Any]:
							_lowercase							:   str 							=   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							:   Union[str, Any] 							=   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}\""""     ,     _lowerCamelCase     ,     )
																					    is not None
																					):
																												_lowercase							:   Optional[int] 							=   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							:   List[str] 							=   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							:   str 							=   [
							    'bos_index',
							    'eos_index',
							    'pad_index',
							    'unk_index',
							    'mask_index',
							    'image_size',
							    'use_cache',
							    'out_features',
							    'out_indices',
							]
							_lowercase							:   Dict 							=   ['encoder_no_repeat_ngram_size']

							# Special cases to be allowed
							_lowercase							:   List[Any] 							=   True
							if not attribute_used:
														_lowercase							:   Optional[int] 							=   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							:   Union[str, Any] 							=   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							:   Optional[Any] 							=   True
																					elif attribute.endswith('_token_id'				):
																												_lowercase							:   Any 							=   True

																					# configuration class specific cases
																					if not case_allowed:
																												_lowercase							:   Any 							=   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    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    List[Any]:
							_lowercase							:   Optional[int] 							=   dict(inspect.signature(config_class.__init__				).parameters				)
							_lowercase							:   Optional[int] 							=   [x for x in list(signature.keys()				) if x not in ['self', 'kwargs']]
							_lowercase							:   Optional[int] 							=   [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							:   Tuple 							=   {}
							if len(config_class.attribute_map				) > 0:
														_lowercase							:   str 							=   {v: k for k, v in config_class.attribute_map.items()}

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

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

							_lowercase							:   Optional[Any] 							=   []
							for config_param, default_value in zip(_lowerCamelCase     ,     _lowerCamelCase				):
														# `attributes` here is all the variant names for `config_param`
														_lowercase							:   Dict 							=   [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(_lowerCamelCase     ,     _lowerCamelCase     ,     _lowerCamelCase     ,     _lowerCamelCase				):
																					unused_attributes.append(attributes[0]				)

							return sorted(_lowerCamelCase				)






def    __magic_name__    (	)     ->    Any:
							_lowercase							:   Any 							=   {}
							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							:   Optional[Any] 							=   [
														    cls
														    for name, cls in inspect.getmembers(
														        inspect.getmodule(_config_class				)     ,     lambda SCREAMING_SNAKE_CASE				: inspect.isclass(_lowerCamelCase				)
														        and issubclass(_lowerCamelCase     ,     _lowerCamelCase				)
														        and inspect.getmodule(_lowerCamelCase				) == inspect.getmodule(_config_class				)     ,     )
														]
														for config_class in config_classes_in_module:
																					_lowercase							:   Dict 							=   check_config_attributes_being_used(_lowerCamelCase				)
																					if len(_lowerCamelCase				) > 0:
																												_lowercase							:   Union[str, Any] 							=   unused_attributes

							if len(_lowerCamelCase				) > 0:
														_lowercase							:   str 							=   '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(_lowerCamelCase				)


if __name__ == "__main__":
							check_config_attributes()












"""simple docstring"""





import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin






class 	a		(   __snake_case    , unittest.TestCase						):
    SCREAMING_SNAKE_CASE		:	Optional[int]		=					DebertaTokenizer
    SCREAMING_SNAKE_CASE		:	Optional[int]		=					True
    SCREAMING_SNAKE_CASE		:	Any		=					DebertaTokenizerFast






    def   UpperCamelCase			(			self	:				Optional[Any]   )	->						Dict:
      super().setUp()

      # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
      lowerCamelCase_       	=		[
          'l',
          'o',
          'w',
          'e',
          'r',
          's',
          't',
          'i',
          'd',
          'n',
          '\u0120',
          '\u0120l',
          '\u0120n',
          '\u0120lo',
          '\u0120low',
          'er',
          '\u0120lowest',
          '\u0120newer',
          '\u0120wider',
          '[UNK]',
      ]
      lowerCamelCase_       	=		dict(zip(__SCREAMING_SNAKE_CASE			,		range(len(__SCREAMING_SNAKE_CASE   )   )   )   )
      lowerCamelCase_       	=		['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
      lowerCamelCase_       	=		{'unk_token': '[UNK]'}

      lowerCamelCase_       	=		os.path.join(self.tmpdirname			,		VOCAB_FILES_NAMES['vocab_file']   )
      lowerCamelCase_       	=		os.path.join(self.tmpdirname			,		VOCAB_FILES_NAMES['merges_file']   )
      with open(self.vocab_file			,		'w'			,		encoding='utf-8'   ) as fp:
        fp.write(json.dumps(__SCREAMING_SNAKE_CASE   ) + '\n'   )
      with open(self.merges_file			,		'w'			,		encoding='utf-8'   ) as fp:
        fp.write('\n'.join(__SCREAMING_SNAKE_CASE   )   )






    def   UpperCamelCase			(			self	:				Tuple			,		**__SCREAMING_SNAKE_CASE	:				Dict   )	->						List[Any]:
      kwargs.update(self.special_tokens_map   )
      return self.tokenizer_class.from_pretrained(self.tmpdirname			,		**__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				str			,		__SCREAMING_SNAKE_CASE	:				Any   )	->						Dict:
      lowerCamelCase_       	=		'lower newer'
      lowerCamelCase_       	=		'lower newer'
      return input_text, output_text






    def   UpperCamelCase			(			self	:				Optional[Any]   )	->						Optional[Any]:
      lowerCamelCase_       	=		self.get_tokenizer()
      lowerCamelCase_       	=		'lower newer'
      lowerCamelCase_       	=		['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
      lowerCamelCase_       	=		tokenizer.tokenize(__SCREAMING_SNAKE_CASE   )
      self.assertListEqual(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		tokens + [tokenizer.unk_token]
      lowerCamelCase_       	=		[0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
      self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE   )			,		__SCREAMING_SNAKE_CASE   )






    def   UpperCamelCase			(			self	:				Union[str, Any]   )	->						Tuple:
      lowerCamelCase_       	=		self.get_tokenizer()
      lowerCamelCase_       	=		tokenizer('Hello'			,		'World'   )
      lowerCamelCase_       	=		[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
      self.assertListEqual(tokd['token_type_ids']			,		__SCREAMING_SNAKE_CASE   )






    @slow
    def   UpperCamelCase			(			self	:				Union[str, Any]   )	->						Tuple:
      lowerCamelCase_       	=		self.tokenizer_class.from_pretrained('microsoft/deberta-base'   )

      lowerCamelCase_       	=		tokenizer.encode('sequence builders'			,		add_special_tokens=__SCREAMING_SNAKE_CASE   )
      lowerCamelCase_       	=		tokenizer.encode('multi-sequence build'			,		add_special_tokens=__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		tokenizer.encode(
          'sequence builders'			,		add_special_tokens=__SCREAMING_SNAKE_CASE			,		add_prefix_space=__SCREAMING_SNAKE_CASE   )
      lowerCamelCase_       	=		tokenizer.encode(
          'sequence builders'			,		'multi-sequence build'			,		add_special_tokens=__SCREAMING_SNAKE_CASE			,		add_prefix_space=__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE   )
      lowerCamelCase_       	=		tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )

      assert encoded_sentence == encoded_text_from_decode
      assert encoded_pair == encoded_pair_from_decode






    @slow
    def   UpperCamelCase			(			self	:				Optional[int]   )	->						Optional[Any]:
      lowerCamelCase_       	=		[self.tokenizer_class]
      if self.test_rust_tokenizer:
        tokenizer_classes.append(self.rust_tokenizer_class   )

      for tokenizer_class in tokenizer_classes:
        lowerCamelCase_       	=		tokenizer_class.from_pretrained('microsoft/deberta-base'   )

        lowerCamelCase_       	=		[
            'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
            'ALBERT incorporates two parameter reduction techniques',
            'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
            ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
            ' vocabulary embedding.',
        ]

        lowerCamelCase_       	=		tokenizer(__SCREAMING_SNAKE_CASE			,		padding=__SCREAMING_SNAKE_CASE   )
        lowerCamelCase_       	=		[tokenizer.decode(__SCREAMING_SNAKE_CASE			,		skip_special_tokens=__SCREAMING_SNAKE_CASE   ) for seq in encoding['input_ids']]

        # fmt: off
        lowerCamelCase_       	=		{
            'input_ids': [
                [1, 2118, 11126, 565, 35, 83, 25191, 163, 18854, 13, 12156, 12, 16101, 25376, 13807, 9, 22205, 27893, 1635, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [1, 2118, 11126, 565, 24536, 80, 43797, 4878, 7373, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [1, 133, 78, 65, 16, 10, 3724, 1538, 33183, 11303, 43797, 1938, 4, 870, 24165, 29105, 5, 739, 32644, 33183, 11303, 36173, 88, 80, 650, 7821, 45940, 6, 52, 2559, 5, 1836, 9, 5, 7397, 13171, 31, 5, 1836, 9, 32644, 33183, 11303, 4, 2]
            ],
            'token_type_ids': [
                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
            ],
            'attention_mask': [
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
            ]
        }
        # fmt: on

        lowerCamelCase_       	=		[
            'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
            'ALBERT incorporates two parameter reduction techniques',
            'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
            ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
            ' vocabulary embedding.',
        ]

        self.assertDictEqual(encoding.data			,		__SCREAMING_SNAKE_CASE   )

        for expected, decoded in zip(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   ):
          self.assertEqual(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )




