



'''simple docstring'''
import os
import re
import shutil
import sys
import tempfile
import unittest

import black


snake_case_  	=  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.
snake_case_  	=  "    def __init__(self, config):\n        super().__init__()\n        self.transform = BertPredictionHeadTransform(config)\n\n        # The output weights are the same as the input embeddings, but there is\n        # an output-only bias for each token.\n        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n        self.bias = nn.Parameter(torch.zeros(config.vocab_size))\n\n        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`\n        self.decoder.bias = self.bias\n\n    def forward(self, hidden_states):\n        hidden_states = self.transform(hidden_states)\n        hidden_states = self.decoder(hidden_states)\n        return hidden_states\n"






class 							lowercase__     (							unittest.TestCase       ):





	def      UpperCamelCase_  (			self :    str			):







							'''simple docstring'''
							_UpperCamelCase :		List[Any]			    =       tempfile.mkdtemp()
							os.makedirs(os.path.join(self.transformer_dir			,'models/bert/'			)			)
							_UpperCamelCase :		List[Any]			    =       self.transformer_dir
							shutil.copy(
							    os.path.join(lowerCamelCase__			,'src/transformers/models/bert/modeling_bert.py'			)			,os.path.join(self.transformer_dir			,'models/bert/modeling_bert.py'			)			,)





	def      UpperCamelCase_  (			self :    Optional[int]			):







							'''simple docstring'''
							_UpperCamelCase :		Union[str, Any]			    =       '''src/transformers'''
							shutil.rmtree(self.transformer_dir			)





	def      UpperCamelCase_  (			self :    List[str]			,lowerCamelCase__ :    Dict			,lowerCamelCase__ :    Any			,lowerCamelCase__ :    List[Any]			,lowerCamelCase__ :    List[str]=None			):







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





	def      UpperCamelCase_  (			self :    List[str]			):







							'''simple docstring'''
							_UpperCamelCase :		Optional[Any]			    =       check_copies.find_code_in_transformers('models.bert.modeling_bert.BertLMPredictionHead'			)
							self.assertEqual(lowerCamelCase__			,lowerCamelCase__			)





	def      UpperCamelCase_  (			self :    List[Any]			):







							'''simple docstring'''
							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'			,lowerCamelCase__			,)

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

							# Copy consistency with a really long name
							_UpperCamelCase :		Optional[Any]			    =       '''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'			,lowerCamelCase__			,lowerCamelCase__			)			,)

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





	def      UpperCamelCase_  (			self :    List[Any]			):







							'''simple docstring'''
							_UpperCamelCase :		Optional[Any]			    =       check_copies.LOCALIZED_READMES['''README_zh-hans.md''']

							_UpperCamelCase :		Tuple			    =       (
							    '''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.'''
							)
							_UpperCamelCase :		str			    =       (
							    '''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'''
							)
							_UpperCamelCase :		Any			    =       (
							    '''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'''
							)

							_UpperCamelCase :		Dict			    =       check_copies.convert_to_localized_md(
							    lowerCamelCase__			,lowerCamelCase__			,localized_readme['format_model_list']			)

							self.assertFalse(lowerCamelCase__			)
							self.assertEqual(lowerCamelCase__			,lowerCamelCase__			)

							_UpperCamelCase :		List[str]			    =       check_copies.convert_to_localized_md(
							    lowerCamelCase__			,lowerCamelCase__			,localized_readme['format_model_list']			)

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

							_UpperCamelCase :		Optional[Any]			    =       (
							    '''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.'''
							)
							_UpperCamelCase :		List[str]			    =       (
							    '''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'''
							)
							_UpperCamelCase :		Optional[int]			    =       (
							    '''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'''
							)

							_UpperCamelCase :		List[Any]			    =       check_copies.convert_to_localized_md(
							    lowerCamelCase__			,lowerCamelCase__			,localized_readme['format_model_list']			)

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







'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case_			:     Any  	=  {
    'configuration_mvp': ['MVP_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MvpConfig', 'MvpOnnxConfig'],
    'tokenization_mvp': ['MvpTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Dict  	=  ['MvpTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     List[Any]  	=  [
					    'MVP_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'MvpForCausalLM',
					    'MvpForConditionalGeneration',
					    'MvpForQuestionAnswering',
					    'MvpForSequenceClassification',
					    'MvpModel',
					    'MvpPreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
					from .tokenization_mvp import MvpTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_mvp_fast import MvpTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_mvp import (
										    MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MvpForCausalLM,
										    MvpForConditionalGeneration,
										    MvpForQuestionAnswering,
										    MvpForSequenceClassification,
										    MvpModel,
										    MvpPreTrainedModel,
										)

else:
					import sys

					snake_case_			:     Optional[Any]  	=  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


