
import inspect
import re

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


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

_lowercase											=    transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
_lowercase											=    re.compile(R"""\[(.+?)\]\((https://huggingface\.co/.+?)\)""")


_lowercase											=    {
    """DecisionTransformerConfig""",
    """EncoderDecoderConfig""",
    """MusicgenConfig""",
    """RagConfig""",
    """SpeechEncoderDecoderConfig""",
    """TimmBackboneConfig""",
    """VisionEncoderDecoderConfig""",
    """VisionTextDualEncoderConfig""",
    """LlamaConfig""",
}
def 							SCREAMING_SNAKE_CASE_	(					UpperCAmelCase_	:     Tuple				)			->						List[Any]:
       SCREAMING_SNAKE_CASE_							:				List[Any]		=None

       # source code of `config_class`
       SCREAMING_SNAKE_CASE_							:				Optional[int]		=inspect.getsource(UpperCAmelCase_				)
       SCREAMING_SNAKE_CASE_							:				Dict		=_re_checkpoint.findall(UpperCAmelCase_				)

       # Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
       # For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
       for ckpt_name, ckpt_link in checkpoints:
              # allow the link to end with `/`
              if ckpt_link.endswith('''/'''				):
                     SCREAMING_SNAKE_CASE_							:				Optional[int]		=ckpt_link[:-1]

              # verify the checkpoint name corresponds to the checkpoint link
              SCREAMING_SNAKE_CASE_							:				str		=f'https://huggingface.co/{ckpt_name}'
              if ckpt_link == ckpt_link_from_name:
                     SCREAMING_SNAKE_CASE_							:				Optional[Any]		=ckpt_name
                     break

       return checkpoint
def 							SCREAMING_SNAKE_CASE_	(					)			->						str:
       SCREAMING_SNAKE_CASE_							:				Optional[Any]		=[]

       for config_class in list(CONFIG_MAPPING.values()				):
              # Skip deprecated models
              if "models.deprecated" in config_class.__module__:
                     continue
              SCREAMING_SNAKE_CASE_							:				str		=get_checkpoint_from_config_class(UpperCAmelCase_				)

              SCREAMING_SNAKE_CASE_							:				str		=config_class.__name__
              if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
                     configs_without_checkpoint.append(UpperCAmelCase_				)

       if len(UpperCAmelCase_				) > 0:
              SCREAMING_SNAKE_CASE_							:				int		='''\n'''.join(sorted(UpperCAmelCase_				)				)
              raise ValueError(f'The following configurations don\'t contain any valid checkpoint:\n{message}'				)


if __name__ == "__main__":
 check_config_docstrings_have_checkpoints()


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_lowercase											=    {
    """configuration_falcon""": ["""FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FalconConfig"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _lowercase											=    [
     """FALCON_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """FalconForCausalLM""",
     """FalconModel""",
     """FalconPreTrainedModel""",
     """FalconForSequenceClassification""",
     """FalconForTokenClassification""",
     """FalconForQuestionAnswering""",
 ]


if TYPE_CHECKING:
 from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_falcon import (
      FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
      FalconForCausalLM,
      FalconForQuestionAnswering,
      FalconForSequenceClassification,
      FalconForTokenClassification,
      FalconModel,
      FalconPreTrainedModel,
  )


else:
 import sys

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