





import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import Callable, Dict, List, Tuple

import timm
import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams, RegNetYaagf, RegNetYaagf, RegNetYaaagf
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCamelCase       :     Union[str, Any]   =     logging.get_logger()



@dataclass
class 					A__   :
      _UpperCAmelCase	:nn.Module
      _UpperCAmelCase	:List[nn.Module]						    =   field(default_factory=__snake_case			)
      _UpperCAmelCase	:list						    =   field(default_factory=__snake_case			)





      def        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					str       	=   len(list(m.modules()   )   ) == 1 or isinstance(A_       ,							nn.Convad   ) or isinstance(A_       ,							nn.BatchNormad   )
       if has_not_submodules:
        self.traced.append(A_   )





      def __call__( self       ,							A_   ):
       '''simple docstring'''




       for m in self.module.modules():
        self.handles.append(m.register_forward_hook(self._forward_hook   )   )
       self.module(A_   )
       [x.remove() for x in self.handles]
       return self





      @property
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return list(filter(lambda A_   : len(list(x.state_dict().keys()   )   ) > 0       ,							self.traced   )   )



@dataclass
class 					A__   :
      _UpperCAmelCase	:nn.Module
      _UpperCAmelCase	:nn.Module
      _UpperCAmelCase	:int						    =   1
      _UpperCAmelCase	:List						    =   field(default_factory=__snake_case			)
      _UpperCAmelCase	:List						    =   field(default_factory=__snake_case			)
      _UpperCAmelCase	:bool						    =   True





      def __call__( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Dict       	=   Tracker(self.dest   )(A_   ).parametrized
       UpperCamelCase	:					List[str]       	=   Tracker(self.src   )(A_   ).parametrized

       UpperCamelCase	:					List[Any]       	=   list(filter(lambda A_   : type(A_   ) not in self.src_skip       ,							A_   )   )
       UpperCamelCase	:					Optional[int]       	=   list(filter(lambda A_   : type(A_   ) not in self.dest_skip       ,							A_   )   )

       if len(A_   ) != len(A_   ) and self.raise_if_mismatch:
        raise Exception(
            F"""Numbers of operations are different. Source module has {len(A_   )} operations while"""
            F""" destination module has {len(A_   )}."""   )

       for dest_m, src_m in zip(A_       ,							A_   ):
        dest_m.load_state_dict(src_m.state_dict()   )
        if self.verbose == 1:
         print(F"""Transfered from={src_m} to={dest_m}"""   )



class 					A__   (       nn.Module			):





      def __init__( self       ,							A_   ):
       '''simple docstring'''




       super().__init__()

       UpperCamelCase	:					List[Tuple[str, nn.Module]]       	=   []
       # - get the stem
       feature_blocks.append(("conv1", model.stem)   )
       # - get all the feature blocks
       for k, v in model.trunk_output.named_children():
        assert k.startswith("block"   ), F"""Unexpected layer name {k}"""
        UpperCamelCase	:					Dict       	=   len(A_   ) + 1
        feature_blocks.append((F"""res{block_index}""", v)   )

       UpperCamelCase	:					Optional[int]       	=   nn.ModuleDict(A_   )





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       return get_trunk_forward_outputs(
           A_       ,							out_feat_keys=A_       ,							feature_blocks=self._feature_blocks       ,							)



class 					A__   (       __snake_case			):





      def        __UpperCamelCase( self       ,							A_   ):
       '''simple docstring'''




       UpperCamelCase	:					Optional[int]       	=   x.split("-"   )
       return x_split[0] + x_split[1] + "_" + "".join(x_split[2:]   )





      def __getitem__( self       ,							A_   ):
       '''simple docstring'''




       if x not in self:
        UpperCamelCase	:					Tuple       	=   self.convert_name_to_timm(A_   )
        UpperCamelCase	:					List[Any]       	=   partial(lambda: (timm.create_model(A_       ,							pretrained=A_   ).eval(), None)   )

       else:
        UpperCamelCase	:					Any       	=   super().__getitem__(A_   )

       return val



class 					A__   (       __snake_case			):





      def __getitem__( self       ,							A_   ):
       '''simple docstring'''




       if "seer" in x and "in1k" not in x:
        UpperCamelCase	:					str       	=   RegNetModel
       else:
        UpperCamelCase	:					Optional[int]       	=   RegNetForImageClassification
       return val



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase     )						-> List[str]:
 for from_key, to_key in keys:
  UpperCamelCase	:					Dict       	=   from_state_dict[from_key].clone()
  print(F"""Copied key={from_key} to={to_key}"""     )
 return to_state_dict



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase = True							,   )						-> int:
 print(F"""Converting {name}..."""     )
 with torch.no_grad():
  UpperCamelCase	,    UpperCamelCase	:					List[Any]       	=   from_model_func()
  UpperCamelCase	:					Optional[Any]       	=   our_model_func(_lowerCAmelCase     ).eval()
  UpperCamelCase	:					Optional[Any]       	=   ModuleTransfer(src=_lowerCAmelCase							,   dest=_lowerCAmelCase							,   raise_if_mismatch=_lowerCAmelCase     )
  UpperCamelCase	:					List[Any]       	=   torch.randn((1, 3, 224, 224)     )
  module_transfer(_lowerCAmelCase     )

 if from_state_dict is not None:
  UpperCamelCase	:					Union[str, Any]       	=   []
  # for seer - in1k finetuned we have to manually copy the head
  if "seer" in name and "in1k" in name:
   UpperCamelCase	:					int       	=   [("0.clf.0.weight", "classifier.1.weight"), ("0.clf.0.bias", "classifier.1.bias")]
  UpperCamelCase	:					Any       	=   manually_copy_vissl_head(_lowerCAmelCase							,   our_model.state_dict()							,   _lowerCAmelCase     )
  our_model.load_state_dict(_lowerCAmelCase     )

 UpperCamelCase	:					Union[str, Any]       	=   our_model(_lowerCAmelCase							,   output_hidden_states=_lowerCAmelCase     )
 UpperCamelCase	:					Union[str, Any]       	=   (
     our_outputs.logits if isinstance(_lowerCAmelCase							,   _lowerCAmelCase     ) else our_outputs.last_hidden_state
 )

 UpperCamelCase	:					Union[str, Any]       	=   from_model(_lowerCAmelCase     )
 UpperCamelCase	:					Tuple       	=   from_output[-1] if type(_lowerCAmelCase     ) is list else from_output

 # now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state
 if "seer" in name and "in1k" in name:
  UpperCamelCase	:					Tuple       	=   our_outputs.hidden_states[-1]

 assert torch.allclose(_lowerCAmelCase							,   _lowerCAmelCase     ), "The model logits don't match the original one."

 if push_to_hub:
  our_model.push_to_hub(
      repo_path_or_name=save_directory / name							,   commit_message="Add model"							,   use_temp_dir=_lowerCAmelCase							,   )

  UpperCamelCase	:					Tuple       	=   224 if "seer" not in name else 384
  # we can use the convnext one
  UpperCamelCase	:					Optional[Any]       	=   AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k"							,   size=_lowerCAmelCase     )
  image_processor.push_to_hub(
      repo_path_or_name=save_directory / name							,   commit_message="Add image processor"							,   use_temp_dir=_lowerCAmelCase							,   )

  print(F"""Pushed {name}"""     )



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase = None							,   _lowerCAmelCase = True     )						-> List[str]:
 UpperCamelCase	:					List[Any]       	=   "imagenet-1k-id2label.json"
 UpperCamelCase	:					List[Any]       	=   1000
 UpperCamelCase	:					Union[str, Any]       	=   (1, num_labels)

 UpperCamelCase	:					int       	=   "huggingface/label-files"
 UpperCamelCase	:					int       	=   num_labels
 UpperCamelCase	:					int       	=   json.load(open(cached_download(hf_hub_url(_lowerCAmelCase							,   _lowerCAmelCase							,   repo_type="dataset"     )     )							,   "r"     )     )
 UpperCamelCase	:					Tuple       	=   {int(_lowerCAmelCase     ): v for k, v in idalabel.items()}

 UpperCamelCase	:					List[Any]       	=   idalabel
 UpperCamelCase	:					Optional[Any]       	=   {v: k for k, v in idalabel.items()}

 UpperCamelCase	:					Dict       	=   partial(_lowerCAmelCase							,   num_labels=_lowerCAmelCase							,   idalabel=_lowerCAmelCase							,   labelaid=_lowerCAmelCase     )

 UpperCamelCase	:					Optional[int]       	=   {
     "regnet-x-002": ImageNetPreTrainedConfig(
         depths=[1, 1, 4, 7]							,   hidden_sizes=[24, 56, 152, 368]							,   groups_width=8							,   layer_type="x"     ),
     "regnet-x-004": ImageNetPreTrainedConfig(
         depths=[1, 2, 7, 12]							,   hidden_sizes=[32, 64, 160, 384]							,   groups_width=16							,   layer_type="x"     ),
     "regnet-x-006": ImageNetPreTrainedConfig(
         depths=[1, 3, 5, 7]							,   hidden_sizes=[48, 96, 240, 528]							,   groups_width=24							,   layer_type="x"     ),
     "regnet-x-008": ImageNetPreTrainedConfig(
         depths=[1, 3, 7, 5]							,   hidden_sizes=[64, 128, 288, 672]							,   groups_width=16							,   layer_type="x"     ),
     "regnet-x-016": ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 2]							,   hidden_sizes=[72, 168, 408, 912]							,   groups_width=24							,   layer_type="x"     ),
     "regnet-x-032": ImageNetPreTrainedConfig(
         depths=[2, 6, 15, 2]							,   hidden_sizes=[96, 192, 432, 1008]							,   groups_width=48							,   layer_type="x"     ),
     "regnet-x-040": ImageNetPreTrainedConfig(
         depths=[2, 5, 14, 2]							,   hidden_sizes=[80, 240, 560, 1360]							,   groups_width=40							,   layer_type="x"     ),
     "regnet-x-064": ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 1]							,   hidden_sizes=[168, 392, 784, 1624]							,   groups_width=56							,   layer_type="x"     ),
     "regnet-x-080": ImageNetPreTrainedConfig(
         depths=[2, 5, 15, 1]							,   hidden_sizes=[80, 240, 720, 1920]							,   groups_width=120							,   layer_type="x"     ),
     "regnet-x-120": ImageNetPreTrainedConfig(
         depths=[2, 5, 11, 1]							,   hidden_sizes=[224, 448, 896, 2240]							,   groups_width=112							,   layer_type="x"     ),
     "regnet-x-160": ImageNetPreTrainedConfig(
         depths=[2, 6, 13, 1]							,   hidden_sizes=[256, 512, 896, 2048]							,   groups_width=128							,   layer_type="x"     ),
     "regnet-x-320": ImageNetPreTrainedConfig(
         depths=[2, 7, 13, 1]							,   hidden_sizes=[336, 672, 1344, 2520]							,   groups_width=168							,   layer_type="x"     ),
     # y variant
     "regnet-y-002": ImageNetPreTrainedConfig(depths=[1, 1, 4, 7]							,   hidden_sizes=[24, 56, 152, 368]							,   groups_width=8     ),
     "regnet-y-004": ImageNetPreTrainedConfig(
         depths=[1, 3, 6, 6]							,   hidden_sizes=[48, 104, 208, 440]							,   groups_width=8     ),
     "regnet-y-006": ImageNetPreTrainedConfig(
         depths=[1, 3, 7, 4]							,   hidden_sizes=[48, 112, 256, 608]							,   groups_width=16     ),
     "regnet-y-008": ImageNetPreTrainedConfig(
         depths=[1, 3, 8, 2]							,   hidden_sizes=[64, 128, 320, 768]							,   groups_width=16     ),
     "regnet-y-016": ImageNetPreTrainedConfig(
         depths=[2, 6, 17, 2]							,   hidden_sizes=[48, 120, 336, 888]							,   groups_width=24     ),
     "regnet-y-032": ImageNetPreTrainedConfig(
         depths=[2, 5, 13, 1]							,   hidden_sizes=[72, 216, 576, 1512]							,   groups_width=24     ),
     "regnet-y-040": ImageNetPreTrainedConfig(
         depths=[2, 6, 12, 2]							,   hidden_sizes=[128, 192, 512, 1088]							,   groups_width=64     ),
     "regnet-y-064": ImageNetPreTrainedConfig(
         depths=[2, 7, 14, 2]							,   hidden_sizes=[144, 288, 576, 1296]							,   groups_width=72     ),
     "regnet-y-080": ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 1]							,   hidden_sizes=[168, 448, 896, 2016]							,   groups_width=56     ),
     "regnet-y-120": ImageNetPreTrainedConfig(
         depths=[2, 5, 11, 1]							,   hidden_sizes=[224, 448, 896, 2240]							,   groups_width=112     ),
     "regnet-y-160": ImageNetPreTrainedConfig(
         depths=[2, 4, 11, 1]							,   hidden_sizes=[224, 448, 1232, 3024]							,   groups_width=112     ),
     "regnet-y-320": ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]							,   hidden_sizes=[232, 696, 1392, 3712]							,   groups_width=232     ),
     # models created by SEER -> https://arxiv.org/abs/2202.08360
     "regnet-y-320-seer": RegNetConfig(depths=[2, 5, 12, 1]							,   hidden_sizes=[232, 696, 1392, 3712]							,   groups_width=232     ),
     "regnet-y-640-seer": RegNetConfig(depths=[2, 5, 12, 1]							,   hidden_sizes=[328, 984, 1968, 4920]							,   groups_width=328     ),
     "regnet-y-1280-seer": RegNetConfig(
         depths=[2, 7, 17, 1]							,   hidden_sizes=[528, 1056, 2904, 7392]							,   groups_width=264     ),
     "regnet-y-2560-seer": RegNetConfig(
         depths=[3, 7, 16, 1]							,   hidden_sizes=[640, 1696, 2544, 5088]							,   groups_width=640     ),
     "regnet-y-10b-seer": ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]							,   hidden_sizes=[2020, 4040, 1_1110, 2_8280]							,   groups_width=1010     ),
     # finetuned on imagenet
     "regnet-y-320-seer-in1k": ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]							,   hidden_sizes=[232, 696, 1392, 3712]							,   groups_width=232     ),
     "regnet-y-640-seer-in1k": ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]							,   hidden_sizes=[328, 984, 1968, 4920]							,   groups_width=328     ),
     "regnet-y-1280-seer-in1k": ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]							,   hidden_sizes=[528, 1056, 2904, 7392]							,   groups_width=264     ),
     "regnet-y-2560-seer-in1k": ImageNetPreTrainedConfig(
         depths=[3, 7, 16, 1]							,   hidden_sizes=[640, 1696, 2544, 5088]							,   groups_width=640     ),
     "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]							,   hidden_sizes=[2020, 4040, 1_1110, 2_8280]							,   groups_width=1010     ),
 }

 UpperCamelCase	:					Optional[Any]       	=   NameToOurModelFuncMap()
 UpperCamelCase	:					List[str]       	=   NameToFromModelFuncMap()
 # add seer weights logic

 def load_using_classy_vision(_lowerCAmelCase							,   _lowerCAmelCase     ) -> Tuple[nn.Module, Dict]:
  UpperCamelCase	:					str       	=   torch.hub.load_state_dict_from_url(_lowerCAmelCase							,   model_dir=str(_lowerCAmelCase     )							,   map_location="cpu"     )
  UpperCamelCase	:					str       	=   model_func()
  # check if we have a head, if yes add it
  UpperCamelCase	:					int       	=   files["classy_state_dict"]["base_model"]["model"]
  UpperCamelCase	:					Tuple       	=   model_state_dict["trunk"]
  model.load_state_dict(_lowerCAmelCase     )
  return model.eval(), model_state_dict["heads"]

 # pretrained
 UpperCamelCase	:					Union[str, Any]       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaagf()     )							,   )

 UpperCamelCase	:					int       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaagf()     )							,   )

 UpperCamelCase	:					str       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaaagf()     )							,   )

 UpperCamelCase	:					Optional[int]       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch"							,   lambda: FakeRegNetVisslWrapper(
         RegNet(RegNetParams(depth=27							,   group_width=1010							,   w_a=1744							,   w_a=620.83							,   w_m=2.52     )     )     )							,   )

 # IN1K finetuned
 UpperCamelCase	:					str       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaagf()     )							,   )

 UpperCamelCase	:					Tuple       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaagf()     )							,   )

 UpperCamelCase	:					Dict       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch"							,   lambda: FakeRegNetVisslWrapper(RegNetYaaagf()     )							,   )

 UpperCamelCase	:					Dict       	=   partial(
     _lowerCAmelCase							,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch"							,   lambda: FakeRegNetVisslWrapper(
         RegNet(RegNetParams(depth=27							,   group_width=1010							,   w_a=1744							,   w_a=620.83							,   w_m=2.52     )     )     )							,   )

 if model_name:
  convert_weight_and_push(
      _lowerCAmelCase							,   names_to_from_model_map[model_name]							,   names_to_ours_model_map[model_name]							,   names_to_config[model_name]							,   _lowerCAmelCase							,   _lowerCAmelCase							,   )
 else:
  for model_name, config in names_to_config.items():
   convert_weight_and_push(
       _lowerCAmelCase							,   names_to_from_model_map[model_name]							,   names_to_ours_model_map[model_name]							,   _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase							,   )
 return config, expected_shape


if __name__ == "__main__":
    __lowerCamelCase       :     Optional[Any]   =     argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--model_name""",
        default=None,
        type=str,
        help=(
            """The name of the model you wish to convert, it must be one of the supported regnet* architecture,"""
            """ currently: regnetx-*, regnety-*. If `None`, all of them will the converted."""
        ),
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""",
        default=None,
        type=Path,
        required=True,
        help="""Path to the output PyTorch model directory.""",
    )
    parser.add_argument(
        """--push_to_hub""",
        default=True,
        type=bool,
        required=False,
        help="""If True, push model and image processor to the hub.""",
    )

    __lowerCamelCase       :     Dict   =     parser.parse_args()

    __lowerCamelCase       :     Path   =     args.pytorch_dump_folder_path
    pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
    convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)







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


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

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


__lowerCamelCase       :     List[str]   =     {
    """DecisionTransformerConfig""",
    """EncoderDecoderConfig""",
    """MusicgenConfig""",
    """RagConfig""",
    """SpeechEncoderDecoderConfig""",
    """TimmBackboneConfig""",
    """VisionEncoderDecoderConfig""",
    """VisionTextDualEncoderConfig""",
    """LlamaConfig""",
}



def 		A_				(     _lowerCAmelCase     )						-> List[str]:
 UpperCamelCase	:					Optional[Any]       	=   None

 # source code of `config_class`
 UpperCamelCase	:					Tuple       	=   inspect.getsource(_lowerCAmelCase     )
 UpperCamelCase	:					Optional[Any]       	=   _re_checkpoint.findall(_lowerCAmelCase     )

 # 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("/"     ):
   UpperCamelCase	:					Dict       	=   ckpt_link[:-1]

  # verify the checkpoint name corresponds to the checkpoint link
  UpperCamelCase	:					Any       	=   F"""https://huggingface.co/{ckpt_name}"""
  if ckpt_link == ckpt_link_from_name:
   UpperCamelCase	:					List[Any]       	=   ckpt_name
   break

 return checkpoint



def 		A_				(     )						-> List[str]:
 UpperCamelCase	:					Optional[int]       	=   []

 for config_class in list(CONFIG_MAPPING.values()     ):
  # Skip deprecated models
  if "models.deprecated" in config_class.__module__:
   continue
  UpperCamelCase	:					Union[str, Any]       	=   get_checkpoint_from_config_class(_lowerCAmelCase     )

  UpperCamelCase	:					Optional[int]       	=   config_class.__name__
  if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
   configs_without_checkpoint.append(_lowerCAmelCase     )

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


if __name__ == "__main__":
    check_config_docstrings_have_checkpoints()
