
"""simple docstring"""





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


__SCREAMING_SNAKE_CASE					:						Union[str, Any]				= os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
__SCREAMING_SNAKE_CASE					:						Union[str, Any]				= '''    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
'''



class __lowerCAmelCase				(					unittest.TestCase      ):




			"""simple docstring"""







			def      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> str:







								"""simple docstring"""
								A_				 =						tempfile.mkdtemp()
								os.makedirs(os.path.join(self.transformer_dir       ,   "models/bert/"	)	)
								A_				 =						self.transformer_dir
								shutil.copy(
								    os.path.join(_A       ,   "src/transformers/models/bert/modeling_bert.py"	)       ,   os.path.join(self.transformer_dir       ,   "models/bert/modeling_bert.py"	)       ,   )




			def      lowerCamelCase__     (				self						:					Any	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						'src/transformers'
								shutil.rmtree(self.transformer_dir	)




			def      lowerCamelCase__     (				self						:					List[Any]       ,   _snake_case						:					Union[str, Any]       ,   _snake_case						:					int       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					Optional[int]=None	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						comment + F'\nclass {class_name}(nn.Module):\n' + class_code
								if overwrite_result is not None:
													A_				 =						comment + F'\nclass {class_name}(nn.Module):\n' + overwrite_result
								A_				 =						black.Mode(target_versions={black.TargetVersion.PYaa}       ,   line_length=119	)
								A_				 =						black.format_str(_A       ,   mode=_A	)
								A_				 =						os.path.join(self.transformer_dir       ,   "new_code.py"	)
								with open(_A       ,   "w"       ,   newline="\n"	) as f:
													f.write(_A	)
								if overwrite_result is None:
													self.assertTrue(len(check_copies.is_copy_consistent(_A	)	) == 0	)
								else:
													check_copies.is_copy_consistent(f.name       ,   overwrite=_A	)
													with open(_A       ,   "r"	) as f:
																		self.assertTrue(f.read()       ,   _A	)




			def      lowerCamelCase__     (				self						:					int	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						check_copies.find_code_in_transformers("models.bert.modeling_bert.BertLMPredictionHead"	)
								self.assertEqual(_A       ,   _A	)




			def      lowerCamelCase__     (				self						:					str	)      -> Any:







								"""simple docstring"""
								# Base copy consistency
								self.check_copy_consistency(
								    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"       ,   "BertLMPredictionHead"       ,   REFERENCE_CODE + "\n"       ,   )

								# With no empty line at the end
								self.check_copy_consistency(
								    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"       ,   "BertLMPredictionHead"       ,   _A       ,   )

								# Copy consistency with rename
								self.check_copy_consistency(
								    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"       ,   "TestModelLMPredictionHead"       ,   re.sub("Bert"       ,   "TestModel"       ,   _A	)       ,   )

								# Copy consistency with a really long name
								A_				 =						'TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'
								self.check_copy_consistency(
								    F'# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}'       ,   F'{long_class_name}LMPredictionHead'       ,   re.sub("Bert"       ,   _A       ,   _A	)       ,   )

								# Copy consistency with overwrite
								self.check_copy_consistency(
								    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"       ,   "TestModelLMPredictionHead"       ,   _A       ,   overwrite_result=re.sub("Bert"       ,   "TestModel"       ,   _A	)       ,   )






			def      lowerCamelCase__     (				self						:					Optional[Any]	)      -> Dict:







								"""simple docstring"""
								A_				 =						check_copies.LOCALIZED_READMES['README_zh-hans.md']

								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'
								    ' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'
								    ' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'
								    ' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1.'
								    ' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),'
								    ' released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'
								    ' lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same'
								    ' method has been applied to compress GPT2 into'
								    ' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'
								    ' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'
								    ' Multilingual BERT into'
								    ' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'
								    ' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**'
								    ' (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders'
								    ' as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang'
								    ' Luong, Quoc V. Le, Christopher D. Manning.'
								)
								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
								    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
								    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
								    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
								)
								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
								    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
								    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
								    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1.'
								    ' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文'
								    ' [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'
								    ' lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same'
								    ' method has been applied to compress GPT2 into'
								    ' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'
								    ' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'
								    ' Multilingual BERT into'
								    ' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'
								    ' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自'
								    ' Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather'
								    ' than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,'
								    ' Christopher D. Manning 发布。\n'
								)

								A_				 =						check_copies.convert_to_localized_md(
								    _A       ,   _A       ,   localized_readme["format_model_list"]	)

								self.assertFalse(_A	)
								self.assertEqual(_A       ,   _A	)

								A_				 =						check_copies.convert_to_localized_md(
								    _A       ,   _A       ,   localized_readme["format_model_list"]	)

								# Check whether the number of models is equal to README.md after conversion.
								self.assertTrue(_A	)

								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'
								    ' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'
								    ' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'
								    ' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.'
								)
								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and'
								    ' the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
								    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
								    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
								)
								A_				 =						(
								    '1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'
								    ' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'
								    ' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'
								    ' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'
								)

								A_				 =						check_copies.convert_to_localized_md(
								    _A       ,   _A       ,   localized_readme["format_model_list"]	)

								# Check if the model link is synchronized.
								self.assertEqual(_A       ,   _A	)






"""simple docstring"""





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
UpperCamelCase_					:						Optional[Any]				= '''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
UpperCamelCase_					:						Union[str, Any]				= direct_transformers_import(PATH_TO_TRANSFORMERS)

UpperCamelCase_					:						List[Any]				= 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)`
UpperCamelCase_					:						str				= re.compile(R'''\[(.+?)\]\((https://huggingface\.co/.+?)\)''')


UpperCamelCase_					:						Dict				= {
    '''DecisionTransformerConfig''',
    '''EncoderDecoderConfig''',
    '''MusicgenConfig''',
    '''RagConfig''',
    '''SpeechEncoderDecoderConfig''',
    '''TimmBackboneConfig''',
    '''VisionEncoderDecoderConfig''',
    '''VisionTextDualEncoderConfig''',
    '''LlamaConfig''',
}
def 							A_     (__a				):

					'''simple docstring'''





					A_				 =						None

					# source code of `config_class`
					A_				 =						inspect.getsource(__a				)
					A_				 =						_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_				 =						ckpt_link[:-1]

										# verify the checkpoint name corresponds to the checkpoint link
										A_				 =						f'https://huggingface.co/{ckpt_name}'
										if ckpt_link == ckpt_link_from_name:
															A_				 =						ckpt_name
															break

					return checkpoint
def 							A_     ():

					'''simple docstring'''





					A_				 =						[]

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

										A_				 =						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_				 =						"\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()




