





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


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

lowercase      :       List[str]									=  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      :       Optional[Any]									=  re.compile(r"""\[(.+?)\]\((https://huggingface\.co/.+?)\)""")


lowercase      :       Optional[Any]									=  {
    """DecisionTransformerConfig""",
    """EncoderDecoderConfig""",
    """MusicgenConfig""",
    """RagConfig""",
    """SpeechEncoderDecoderConfig""",
    """TimmBackboneConfig""",
    """VisionEncoderDecoderConfig""",
    """VisionTextDualEncoderConfig""",
    """LlamaConfig""",
}



def A_	(		A__				)  ->		Optional[Any]:
       a__						:	List[str] =				None

       # source code of `config_class`
       a__						:	Tuple =				inspect.getsource(A__				)
       a__						:	Any =				_re_checkpoint.findall(A__				)

       # 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('/'				):
                     a__						:	Union[str, Any] =				ckpt_link[:-1]

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

       return checkpoint



def A_	(		)  ->		List[str]:
       a__						:	Tuple =				[]

       for config_class in list(CONFIG_MAPPING.values()				):
              # Skip deprecated models
              if "models.deprecated" in config_class.__module__:
                     continue
              a__						:	Dict =				get_checkpoint_from_config_class(A__				)

              a__						:	List[str] =				config_class.__name__
              if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
                     configs_without_checkpoint.append(A__				)

       if len(A__				) > 0:
              a__						:	Dict =				'\n'.join(sorted(A__				)				)
              raise ValueError(F'The following configurations don\'t contain any valid checkpoint:\n{message}'				)


if __name__ == "__main__":
    check_config_docstrings_have_checkpoints()






'''simple docstring'''






class    __snake_case       :







    """simple docstring"""



    def __init__(   self    :  int    ,						lowerCamelCase    :  int    ,						lowerCamelCase    :  int=None    ,						lowerCamelCase    :  int=None		)   ->  str:
      lowerCAmelCase_			:      str			=   data
      lowerCAmelCase_			:      Optional[Any]			=   previous
      lowerCAmelCase_			:      int			=   next_node

    def __str__(   self    :  Any		)   ->  str:
      return F'{self.data}'

    def __lowercase   (   self    :  Optional[Any]		)   ->  int:
      return self.data

    def __lowercase   (   self    :  str		)   ->  List[str]:
      return self.next





    def __lowercase   (   self    :  int		)   ->  Optional[int]:
      return self.previous







class    __snake_case       :







    """simple docstring"""



    def __init__(   self    :  Union[str, Any]    ,						lowerCamelCase    :  Optional[int]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Optional[Any]			=   head

    def __iter__(   self    :  str		)   ->  Optional[Any]:
      return self





    def __lowercase   (   self    :  Union[str, Any]		)   ->  Dict:
      if not self.current:
        raise StopIteration
      else:
        lowerCAmelCase_			:      Dict			=   self.current.get_data()
        lowerCAmelCase_			:      Tuple			=   self.current.get_next()
        return value







class    __snake_case       :







    """simple docstring"""



    def __init__(   self    :  Union[str, Any]		)   ->  Any:
      lowerCAmelCase_			:      Optional[Any]			=   None  # First node in list
      lowerCAmelCase_			:      Optional[Any]			=   None  # Last node in list

    def __str__(   self    :  Optional[int]		)   ->  Dict:
      lowerCAmelCase_			:      str			=   self.head
      lowerCAmelCase_			:      Tuple			=   []
      while current is not None:
        nodes.append(current.get_data()		)
        lowerCAmelCase_			:      str			=   current.get_next()
      return " ".join(str(lowerCamelCase		) for node in nodes		)

    def __contains__(   self    :  List[Any]    ,						lowerCamelCase    :  int		)   ->  List[str]:
      lowerCAmelCase_			:      List[str]			=   self.head
      while current:
        if current.get_data() == value:
          return True
        lowerCAmelCase_			:      List[Any]			=   current.get_next()
      return False

    def __iter__(   self    :  str		)   ->  Optional[Any]:
      return LinkedListIterator(self.head		)

    def __lowercase   (   self    :  Dict		)   ->  Optional[int]:
      if self.head:
        return self.head.get_data()
      return None

    def __lowercase   (   self    :  List[str]		)   ->  Optional[Any]:
      if self.tail:
        return self.tail.get_data()
      return None

    def __lowercase   (   self    :  Optional[Any]    ,						lowerCamelCase    :  Node		)   ->  None:
      if self.head is None:
        lowerCAmelCase_			:      Union[str, Any]			=   node
        lowerCAmelCase_			:      List[str]			=   node
      else:
        self.insert_before_node(self.head    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Tuple    ,						lowerCamelCase    :  Node		)   ->  None:
      if self.head is None:
        self.set_head(lowerCamelCase		)
      else:
        self.insert_after_node(self.tail    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Union[str, Any]    ,						lowerCamelCase    :  int		)   ->  None:
      lowerCAmelCase_			:      int			=   Node(lowerCamelCase		)
      if self.head is None:
        self.set_head(lowerCamelCase		)
      else:
        self.set_tail(lowerCamelCase		)

    def __lowercase   (   self    :  Optional[Any]    ,						lowerCamelCase    :  Node    ,						lowerCamelCase    :  Node		)   ->  None:
      lowerCAmelCase_			:      Optional[int]			=   node
      lowerCAmelCase_			:      List[Any]			=   node.previous

      if node.get_previous() is None:
        lowerCAmelCase_			:      Tuple			=   node_to_insert
      else:
        lowerCAmelCase_			:      Dict			=   node_to_insert

      lowerCAmelCase_			:      Optional[int]			=   node_to_insert

    def __lowercase   (   self    :  Union[str, Any]    ,						lowerCamelCase    :  Node    ,						lowerCamelCase    :  Node		)   ->  None:
      lowerCAmelCase_			:      Optional[int]			=   node
      lowerCAmelCase_			:      Tuple			=   node.next

      if node.get_next() is None:
        lowerCAmelCase_			:      Tuple			=   node_to_insert
      else:
        lowerCAmelCase_			:      Tuple			=   node_to_insert

      lowerCAmelCase_			:      Optional[Any]			=   node_to_insert

    def __lowercase   (   self    :  Dict    ,						lowerCamelCase    :  int    ,						lowerCamelCase    :  int		)   ->  None:
      lowerCAmelCase_			:      List[str]			=   1
      lowerCAmelCase_			:      Tuple			=   Node(lowerCamelCase		)
      lowerCAmelCase_			:      List[Any]			=   self.head
      while node:
        if current_position == position:
          self.insert_before_node(lowerCamelCase    ,						lowerCamelCase		)
          return
        current_position += 1
        lowerCAmelCase_			:      str			=   node.next
      self.insert_after_node(self.tail    ,						lowerCamelCase		)

    def __lowercase   (   self    :  int    ,						lowerCamelCase    :  int		)   ->  Node:
      lowerCAmelCase_			:      List[Any]			=   self.head
      while node:
        if node.get_data() == item:
          return node
        lowerCAmelCase_			:      List[Any]			=   node.get_next()
      raise Exception("""Node not found"""		)

    def __lowercase   (   self    :  str    ,						lowerCamelCase    :  str		)   ->  int:
      if (node := self.get_node(lowerCamelCase		)) is not None:
        if node == self.head:
          lowerCAmelCase_			:      Any			=   self.head.get_next()

        if node == self.tail:
          lowerCAmelCase_			:      Optional[int]			=   self.tail.get_previous()

        self.remove_node_pointers(lowerCamelCase		)

    @staticmethod
    def __lowercase   (   lowerCamelCase    :  Node		)   ->  None:
      if node.get_next():
        lowerCAmelCase_			:      Tuple			=   node.previous

      if node.get_previous():
        lowerCAmelCase_			:      Any			=   node.next

      lowerCAmelCase_			:      List[Any]			=   None
      lowerCAmelCase_			:      Any			=   None





    def __lowercase   (   self    :  str		)   ->  Optional[Any]:
      return self.head is None







def 				UpperCamelCase_			(    ):
  '''simple docstring'''







if __name__ == "__main__":
  import doctest

  doctest.testmod()



