

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


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

__lowerCamelCase										=		transformers.models.auto.configuration_auto.CONFIG_MAPPING

__lowerCamelCase										=		{
    # 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						) ->      str:
 __magic_name__     =      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
   ):
    __magic_name__     =      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
   ):
    __magic_name__     =      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:
     __magic_name__     =      True
   if attribute_used:
    break
  if attribute_used:
   break

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

 # Special cases to be allowed
 __magic_name__     =      True
 if not attribute_used:
  __magic_name__     =      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:
    __magic_name__     =      True
   elif attribute in ["tie_word_embeddings"] and default_value is False:
    __magic_name__     =      True

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

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

 return attribute_used or case_allowed





def 	lowercase      (   __UpperCamelCase						) ->      Optional[int]:
 __magic_name__     =      dict(inspect.signature(config_class.__init__						).parameters						)
 __magic_name__     =      [x for x in list(signature.keys()						) if x not in ['''self''', '''kwargs''']]
 __magic_name__     =      [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
 __magic_name__     =      {}
 if len(config_class.attribute_map						) > 0:
  __magic_name__     =      {v: k for k, v in config_class.attribute_map.items()}

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

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

 __magic_name__     =      []
 for config_param, default_value in zip(__UpperCamelCase      ,   __UpperCamelCase						):
  # `attributes` here is all the variant names for `config_param`
  __magic_name__     =      [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      (   ) ->      List[Any]:
 __magic_name__     =      {}
 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.)
  __magic_name__     =      [
      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:
   __magic_name__     =      check_config_attributes_being_used(__UpperCamelCase						)
   if len(__UpperCamelCase						) > 0:
    __magic_name__     =      unused_attributes

 if len(__UpperCamelCase						) > 0:
  __magic_name__     =      '''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()




"""simple docstring"""






import json
import os
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from requests.exceptions import HTTPError

from transformers.utils import (
    CONFIG_NAME,
    FLAX_WEIGHTS_NAME,
    TF2_WEIGHTS_NAME,
    TRANSFORMERS_CACHE,
    WEIGHTS_NAME,
    cached_file,
    get_file_from_repo,
    has_file,
)


__lowerCamelCase										=		"hf-internal-testing/tiny-random-bert"
__lowerCamelCase										=		os.path.join(TRANSFORMERS_CACHE, "models--hf-internal-testing--tiny-random-bert")
__lowerCamelCase										=		"9b8c223d42b2188cb49d29af482996f9d0f3e5a6"
class        _lowercase					(     unittest.TestCase     ):







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_       )
      # Should have downloaded the file in here
      self.assertTrue(os.path.isdir(UpperCamelCase_       )       )
      # Cache should contain at least those three subfolders:
      for subfolder in ["blobs", "refs", "snapshots"]:
       self.assertTrue(os.path.isdir(os.path.join(UpperCamelCase_ ,						UpperCamelCase_       )       )       )
      with open(os.path.join(UpperCamelCase_ ,						'''refs''' ,						'''main'''       )       ) as f:
       __magic_name__     =      f.read()
      self.assertEqual(UpperCamelCase_ ,						os.path.join(UpperCamelCase_ ,						'''snapshots''' ,						UpperCamelCase_ ,						UpperCamelCase_       )       )
      self.assertTrue(os.path.isfile(UpperCamelCase_       )       )

      # File is cached at the same place the second time.
      __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_       )
      self.assertEqual(UpperCamelCase_ ,						UpperCamelCase_       )

      # Using a specific revision to test the full commit hash.
      __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_ ,						revision='''9b8c223'''       )
      self.assertEqual(UpperCamelCase_ ,						os.path.join(UpperCamelCase_ ,						'''snapshots''' ,						UpperCamelCase_ ,						UpperCamelCase_       )       )







     def 	lowerCAmelCase__    (      self       ):
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid model identifier'''       ):
       __magic_name__     =      cached_file('''tiny-random-bert''' ,						UpperCamelCase_       )

      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid git identifier'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						UpperCamelCase_ ,						revision='''aaaa'''       )

      with self.assertRaisesRegex(UpperCamelCase_ ,						'''does not appear to have a file named'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf'''       )







     def 	lowerCAmelCase__    (      self       ):
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''does not appear to have a file named'''       ):
       __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf'''       )

      with open(os.path.join(UpperCamelCase_ ,						'''refs''' ,						'''main'''       )       ) as f:
       __magic_name__     =      f.read()
      self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase_ ,						'''.no_exist''' ,						UpperCamelCase_ ,						'''conf'''       )       )       )

      __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf''' ,						_raise_exceptions_for_missing_entries=UpperCamelCase_       )
      self.assertIsNone(UpperCamelCase_       )

      __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf''' ,						local_files_only=UpperCamelCase_ ,						_raise_exceptions_for_missing_entries=UpperCamelCase_       )
      self.assertIsNone(UpperCamelCase_       )

      __magic_name__     =      mock.Mock()
      __magic_name__     =      500
      __magic_name__     =      {}
      __magic_name__     =      HTTPError
      __magic_name__     =      {}

      # Under the mock environment we get a 500 error when trying to reach the tokenizer.
      with mock.patch('''requests.Session.request''' ,						return_value=UpperCamelCase_       ) as mock_head:
       __magic_name__     =      cached_file(UpperCamelCase_ ,						'''conf''' ,						_raise_exceptions_for_connection_errors=UpperCamelCase_       )
       self.assertIsNone(UpperCamelCase_       )
       # This check we did call the fake head request
       mock_head.assert_called()







     def 	lowerCAmelCase__    (      self       ):
      self.assertTrue(has_file('''hf-internal-testing/tiny-bert-pt-only''' ,						UpperCamelCase_       )       )
      self.assertFalse(has_file('''hf-internal-testing/tiny-bert-pt-only''' ,						UpperCamelCase_       )       )
      self.assertFalse(has_file('''hf-internal-testing/tiny-bert-pt-only''' ,						UpperCamelCase_       )       )







     def 	lowerCAmelCase__    (      self       ):
      # `get_file_from_repo` returns None if the file does not exist
      self.assertIsNone(get_file_from_repo('''bert-base-cased''' ,						'''ahah.txt'''       )       )

      # The function raises if the repository does not exist.
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid model identifier'''       ):
       get_file_from_repo('''bert-base-case''' ,						UpperCamelCase_       )

      # The function raises if the revision does not exist.
      with self.assertRaisesRegex(UpperCamelCase_ ,						'''is not a valid git identifier'''       ):
       get_file_from_repo('''bert-base-cased''' ,						UpperCamelCase_ ,						revision='''ahaha'''       )

      __magic_name__     =      get_file_from_repo('''bert-base-cased''' ,						UpperCamelCase_       )
      # The name is the cached name which is not very easy to test, so instead we load the content.
      __magic_name__     =      json.loads(open(UpperCamelCase_ ,						'''r'''       ).read()       )
      self.assertEqual(config['''hidden_size'''] ,						768       )







     def 	lowerCAmelCase__    (      self       ):
      with tempfile.TemporaryDirectory() as tmp_dir:
       __magic_name__     =      Path(UpperCamelCase_       ) / '''a.txt'''
       filename.touch()
       self.assertEqual(get_file_from_repo(UpperCamelCase_ ,						'''a.txt'''       ) ,						str(UpperCamelCase_       )       )

       self.assertIsNone(get_file_from_repo(UpperCamelCase_ ,						'''b.txt'''       )       )

