





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

import black


UpperCAmelCase_					:   Optional[int] 							=						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.
UpperCAmelCase_					:   List[str] 							=						'''    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 							lowercase__    (							unittest.TestCase  ):







  def 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       Optional[int]    =		tempfile.mkdtemp()
       os.makedirs(os.path.join(self.transformer_dir    ,						"""models/bert/"""						)						)
       lowerCAmelCase_					:       List[Any]    =		self.transformer_dir
       shutil.copy(
           os.path.join(_lowercase    ,						"""src/transformers/models/bert/modeling_bert.py"""						)    ,						os.path.join(self.transformer_dir    ,						"""models/bert/modeling_bert.py"""						)    ,						)







  def 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       int    =		"""src/transformers"""
       shutil.rmtree(self.transformer_dir						)







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







  def 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       str    =		check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""						)
       self.assertEqual(_lowercase    ,						_lowercase						)







  def 	UpperCAmelCase__		(	self						):
       # 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"""    ,						_lowercase    ,						)

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

       # Copy consistency with a really long name
       lowerCAmelCase_					:       Tuple    =		"""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"""    ,						_lowercase    ,						_lowercase						)    ,						)

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







  def 	UpperCAmelCase__		(	self						):
       lowerCAmelCase_					:       Tuple    =		check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

       lowerCAmelCase_					:       Optional[int]    =		(
           """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."""
       )
       lowerCAmelCase_					:       Union[str, 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 发布。\n"""
       )
       lowerCAmelCase_					:       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 发布。\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"""
       )

       lowerCAmelCase_   ,  lowerCAmelCase_					:       Tuple    =		check_copies.convert_to_localized_md(
           _lowercase    ,						_lowercase    ,						localized_readme["""format_model_list"""]						)

       self.assertFalse(_lowercase						)
       self.assertEqual(_lowercase    ,						_lowercase						)

       lowerCAmelCase_   ,  lowerCAmelCase_					:       Optional[int]    =		check_copies.convert_to_localized_md(
           _lowercase    ,						_lowercase    ,						localized_readme["""format_model_list"""]						)

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

       lowerCAmelCase_					:       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."""
       )
       lowerCAmelCase_					:       Optional[int]    =		(
           """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"""
       )
       lowerCAmelCase_					:       Dict    =		(
           """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"""
       )

       lowerCAmelCase_   ,  lowerCAmelCase_					:       str    =		check_copies.convert_to_localized_md(
           _lowercase    ,						_lowercase    ,						localized_readme["""format_model_list"""]						)

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







from collections import namedtuple

UpperCAmelCase_					:   Union[str, Any] 							=						namedtuple("""from_to""", """from_ to""")

UpperCAmelCase_					:   int 							=						{
    """cubicmeter""": from_to(1, 1),
    """litre""": from_to(0.0_01, 10_00),
    """kilolitre""": from_to(1, 1),
    """gallon""": from_to(0.0_04_54, 2_64.1_72),
    """cubicyard""": from_to(0.7_64_55, 1.3_07_95),
    """cubicfoot""": from_to(0.0_28, 35.31_47),
    """cup""": from_to(0.0_00_23_65_88, 42_26.75),
}






def 							_lowerCAmelCase (  _a   :					float					,   _a   :					str					,   _a   :					str			)	->			float:
     if from_type not in METRIC_CONVERSION:
          raise ValueError(
              F'Invalid \'from_type\' value: {from_type!r}  Supported values are:\n'
              + """, """.join(_a			)			)
     if to_type not in METRIC_CONVERSION:
          raise ValueError(
              F'Invalid \'to_type\' value: {to_type!r}.  Supported values are:\n'
              + """, """.join(_a			)			)
     return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
      import doctest

      doctest.testmod()
