




"""simple docstring"""







import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
SCREAMING_SNAKE_CASE_	     =       sys.version_info >= (3, 10)





def      __snake_case (				_lowercase=None			,_lowercase=None    ):


    """simple docstring"""







    return field(default_factory=lambda: default			,metadata=_lowercase    )

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       42
   A_				      =       42
   A_				      =       42
   A_				      =       42

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       42
   A_				      =       field(default='''toto'''	, metadata={'''help''': '''help message'''}			)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       False
   A_				      =       True
   A_				      =       None

class 				snake_case_			(					lowerCamelCase_			):







   """simple docstring"""




   A_				      =       '''titi'''
   A_				      =       '''toto'''

class 				snake_case_			(					lowerCamelCase_			):







   """simple docstring"""




   A_				      =       '''titi'''
   A_				      =       '''toto'''
   A_				      =       42

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       "toto"







   def   UpperCAmelCase__			(		self)				->   Dict:
       UpperCamelCase              =	BasicEnum(self.foo)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       "toto"







   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	MixedTypeEnum(self.foo)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       None
   A_				      =       field(default=lowerCamelCase_	, metadata={'''help''': '''help message'''}			)
   A_				      =       None
   A_				      =       list_field(default=[]			)
   A_				      =       list_field(default=[]			)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       list_field(default=[]			)
   A_				      =       list_field(default=[1, 2, 3]			)
   A_				      =       list_field(default=['''Hallo''', '''Bonjour''', '''Hello''']			)
   A_				      =       list_field(default=[0.1, 0.2, 0.3]			)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       field()
   A_				      =       field()
   A_				      =       field()







   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	BasicEnum(self.required_enum)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       42
   A_				      =       field()
   A_				      =       None
   A_				      =       field(default='''toto'''	, metadata={'''help''': '''help message'''}			)
   A_				      =       list_field(default=['''Hallo''', '''Bonjour''', '''Hello''']			)


if is_python_no_less_than_3_10:

  @dataclass
  class 				snake_case_			:







     """simple docstring"""




     A_				      =       False
     A_				      =       True
     A_				      =       None

  @dataclass
  class 				snake_case_			:







     """simple docstring"""




     A_				      =       None
     A_				      =       field(default=lowerCamelCase_	, metadata={'''help''': '''help message'''}			)
     A_				      =       None
     A_				      =       list_field(default=[]			)
     A_				      =       list_field(default=[]			)


class 				snake_case_			(					unittest.TestCase			):







   """simple docstring"""




   def   UpperCAmelCase__			(		self       ,					lowerCamelCase_       ,					lowerCamelCase_)				->   Tuple:
       self.assertEqual(len(a._actions)       ,					len(b._actions))
       for x, y in zip(a._actions       ,					b._actions):
           UpperCamelCase              =	{k: v for k, v in vars(lowerCamelCase_).items() if k != '''container'''}
           UpperCamelCase              =	{k: v for k, v in vars(lowerCamelCase_).items() if k != '''container'''}

           # Choices with mixed type have custom function as "type"
           # So we need to compare results directly for equality
           if xx.get('''choices'''       ,					lowerCamelCase_) and yy.get('''choices'''       ,					lowerCamelCase_):
               for expected_choice in yy["choices"] + xx["choices"]:
                   self.assertEqual(xx['''type'''](lowerCamelCase_)       ,					yy['''type'''](lowerCamelCase_))
               del xx["type"], yy["type"]

           self.assertEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument('''--bar'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument('''--baz'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument('''--flag'''       ,					type=lowerCamelCase_       ,					default=lowerCamelCase_       ,					const=lowerCamelCase_       ,					nargs='''?''')
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

       UpperCamelCase              =	['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
       ((UpperCamelCase)       ,	)              =	parser.parse_args_into_dataclasses(lowerCamelCase_       ,					look_for_args_file=lowerCamelCase_)
       self.assertFalse(example.flag)







   def   UpperCAmelCase__			(		self)				->   Tuple:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo'''       ,					default=4_2       ,					type=lowerCamelCase_)
       expected.add_argument('''--baz'''       ,					default='''toto'''       ,					type=lowerCamelCase_       ,					help='''help message''')
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo'''       ,					type=lowerCamelCase_       ,					default=lowerCamelCase_       ,					const=lowerCamelCase_       ,					nargs='''?''')
       expected.add_argument('''--baz'''       ,					type=lowerCamelCase_       ,					default=lowerCamelCase_       ,					const=lowerCamelCase_       ,					nargs='''?''')
       # A boolean no_* argument always has to come after its "default: True" regular counter-part
       # and its default must be set to False
       expected.add_argument('''--no_baz'''       ,					action='''store_false'''       ,					default=lowerCamelCase_       ,					dest='''baz''')
       expected.add_argument('''--opt'''       ,					type=lowerCamelCase_       ,					default=lowerCamelCase_)

       UpperCamelCase              =	[WithDefaultBoolExample]
       if is_python_no_less_than_3_10:
           dataclass_types.append(lowerCamelCase_)

       for dataclass_type in dataclass_types:
           UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)
           self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

           UpperCamelCase              =	parser.parse_args([])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					opt=lowerCamelCase_))

           UpperCamelCase              =	parser.parse_args(['''--foo''', '''--no_baz'''])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					opt=lowerCamelCase_))

           UpperCamelCase              =	parser.parse_args(['''--foo''', '''--baz'''])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					opt=lowerCamelCase_))

           UpperCamelCase              =	parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True'''])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					opt=lowerCamelCase_))

           UpperCamelCase              =	parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False'''])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					opt=lowerCamelCase_))







   def   UpperCAmelCase__			(		self)				->   Tuple:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument(
           '''--foo'''       ,					default='''toto'''       ,					choices=['''titi''', '''toto''', 4_2]       ,					type=make_choice_type_function(['''titi''', '''toto''', 4_2])       ,					)
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

       UpperCamelCase              =	parser.parse_args([])
       self.assertEqual(args.foo       ,					'''toto''')
       UpperCamelCase              =	parser.parse_args_into_dataclasses([])[0]
       self.assertEqual(enum_ex.foo       ,					MixedTypeEnum.toto)

       UpperCamelCase              =	parser.parse_args(['''--foo''', '''titi'''])
       self.assertEqual(args.foo       ,					'''titi''')
       UpperCamelCase              =	parser.parse_args_into_dataclasses(['''--foo''', '''titi'''])[0]
       self.assertEqual(enum_ex.foo       ,					MixedTypeEnum.titi)

       UpperCamelCase              =	parser.parse_args(['''--foo''', '''42'''])
       self.assertEqual(args.foo       ,					4_2)
       UpperCamelCase              =	parser.parse_args_into_dataclasses(['''--foo''', '''42'''])[0]
       self.assertEqual(enum_ex.foo       ,					MixedTypeEnum.fourtytwo)







   def   UpperCAmelCase__			(		self)				->   List[Any]:

       @dataclass
       class 				snake_case_			:







          """simple docstring"""




          A_				      =       "toto"
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument(
           '''--foo'''       ,					default='''toto'''       ,					choices=('''titi''', '''toto''', 4_2)       ,					type=make_choice_type_function(['''titi''', '''toto''', 4_2])       ,					)
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

       UpperCamelCase              =	parser.parse_args([])
       self.assertEqual(args.foo       ,					'''toto''')

       UpperCamelCase              =	parser.parse_args(['''--foo''', '''titi'''])
       self.assertEqual(args.foo       ,					'''titi''')

       UpperCamelCase              =	parser.parse_args(['''--foo''', '''42'''])
       self.assertEqual(args.foo       ,					4_2)







   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo_int'''       ,					nargs='''+'''       ,					default=[]       ,					type=lowerCamelCase_)
       expected.add_argument('''--bar_int'''       ,					nargs='''+'''       ,					default=[1, 2, 3]       ,					type=lowerCamelCase_)
       expected.add_argument('''--foo_str'''       ,					nargs='''+'''       ,					default=['''Hallo''', '''Bonjour''', '''Hello''']       ,					type=lowerCamelCase_)
       expected.add_argument('''--foo_float'''       ,					nargs='''+'''       ,					default=[0.1, 0.2, 0.3]       ,					type=lowerCamelCase_)

       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

       UpperCamelCase              =	parser.parse_args([])
       self.assertEqual(
           lowerCamelCase_       ,					Namespace(foo_int=[]       ,					bar_int=[1, 2, 3]       ,					foo_str=['''Hallo''', '''Bonjour''', '''Hello''']       ,					foo_float=[0.1, 0.2, 0.3])       ,					)

       UpperCamelCase              =	parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split())
       self.assertEqual(lowerCamelCase_       ,					Namespace(foo_int=[1]       ,					bar_int=[2, 3]       ,					foo_str=['''a''', '''b''', '''c''']       ,					foo_float=[0.1, 0.7]))







   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo'''       ,					default=lowerCamelCase_       ,					type=lowerCamelCase_)
       expected.add_argument('''--bar'''       ,					default=lowerCamelCase_       ,					type=lowerCamelCase_       ,					help='''help message''')
       expected.add_argument('''--baz'''       ,					default=lowerCamelCase_       ,					type=lowerCamelCase_)
       expected.add_argument('''--ces'''       ,					nargs='''+'''       ,					default=[]       ,					type=lowerCamelCase_)
       expected.add_argument('''--des'''       ,					nargs='''+'''       ,					default=[]       ,					type=lowerCamelCase_)

       UpperCamelCase              =	[OptionalExample]
       if is_python_no_less_than_3_10:
           dataclass_types.append(lowerCamelCase_)

       for dataclass_type in dataclass_types:
           UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

           self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)

           UpperCamelCase              =	parser.parse_args([])
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=lowerCamelCase_       ,					bar=lowerCamelCase_       ,					baz=lowerCamelCase_       ,					ces=[]       ,					des=[]))

           UpperCamelCase              =	parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split())
           self.assertEqual(lowerCamelCase_       ,					Namespace(foo=1_2       ,					bar=3.14       ,					baz='''42'''       ,					ces=['''a''', '''b''', '''c''']       ,					des=[1, 2, 3]))







   def   UpperCAmelCase__			(		self)				->   Dict:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--required_list'''       ,					nargs='''+'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument('''--required_str'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument(
           '''--required_enum'''       ,					type=make_choice_type_function(['''titi''', '''toto'''])       ,					choices=['''titi''', '''toto''']       ,					required=lowerCamelCase_       ,					)
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Union[str, Any]:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	argparse.ArgumentParser()
       expected.add_argument('''--foo'''       ,					type=lowerCamelCase_       ,					required=lowerCamelCase_)
       expected.add_argument(
           '''--required_enum'''       ,					type=make_choice_type_function(['''titi''', '''toto'''])       ,					choices=['''titi''', '''toto''']       ,					required=lowerCamelCase_       ,					)
       expected.add_argument('''--opt'''       ,					type=lowerCamelCase_       ,					default=lowerCamelCase_)
       expected.add_argument('''--baz'''       ,					default='''toto'''       ,					type=lowerCamelCase_       ,					help='''help message''')
       expected.add_argument('''--foo_str'''       ,					nargs='''+'''       ,					default=['''Hallo''', '''Bonjour''', '''Hello''']       ,					type=lowerCamelCase_)
       self.argparsersEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	{
           '''foo''': 1_2,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }

       UpperCamelCase              =	parser.parse_dict(lowerCamelCase_)[0]
       UpperCamelCase              =	BasicExample(**lowerCamelCase_)
       self.assertEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Union[str, Any]:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	{
           '''foo''': 1_2,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
           '''extra''': 4_2,
       }

       self.assertRaises(lowerCamelCase_       ,					parser.parse_dict       ,					lowerCamelCase_       ,					allow_extra_keys=lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	{
           '''foo''': 1_2,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }
       with tempfile.TemporaryDirectory() as tmp_dir:
           UpperCamelCase              =	os.path.join(lowerCamelCase_       ,					'''temp_json''')
           os.mkdir(lowerCamelCase_)
           with open(temp_local_path + '''.json'''       ,					'''w+''') as f:
               json.dump(lowerCamelCase_       ,					lowerCamelCase_)
           UpperCamelCase              =	parser.parse_yaml_file(Path(temp_local_path + '''.json'''))[0]

       UpperCamelCase              =	BasicExample(**lowerCamelCase_)
       self.assertEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)

       UpperCamelCase              =	{
           '''foo''': 1_2,
           '''bar''': 3.14,
           '''baz''': '''42''',
           '''flag''': True,
       }
       with tempfile.TemporaryDirectory() as tmp_dir:
           UpperCamelCase              =	os.path.join(lowerCamelCase_       ,					'''temp_yaml''')
           os.mkdir(lowerCamelCase_)
           with open(temp_local_path + '''.yaml'''       ,					'''w+''') as f:
               yaml.dump(lowerCamelCase_       ,					lowerCamelCase_)
           UpperCamelCase              =	parser.parse_yaml_file(Path(temp_local_path + '''.yaml'''))[0]
       UpperCamelCase              =	BasicExample(**lowerCamelCase_)
       self.assertEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	HfArgumentParser(lowerCamelCase_)
       self.assertIsNotNone(lowerCamelCase_)





'''simple docstring'''






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

import black


A_			      =		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.
A_			      =		"    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 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           snake_case__       :   str	      =    tempfile.mkdtemp()
           os.makedirs(os.path.join(self.transformer_dir     ,							'models/bert/'			)			)
           snake_case__       :   Optional[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 			_lowerCAmelCase      (     self     :					int			):
           snake_case__       :   Union[str, Any]	      =    'src/transformers'
           shutil.rmtree(self.transformer_dir			)





     def 			_lowerCAmelCase      (     self     :					Tuple     ,							__lowerCamelCase     :					Tuple     ,							__lowerCamelCase     :					Dict     ,							__lowerCamelCase     :					Tuple     ,							__lowerCamelCase     :					List[Any]=None			):
           snake_case__       :   Optional[int]	      =    comment + F"\nclass {class_name}(nn.Module):\n" + class_code
           if overwrite_result is not None:
                 snake_case__       :   List[Any]	      =    comment + F"\nclass {class_name}(nn.Module):\n" + overwrite_result
           snake_case__       :   Optional[int]	      =    black.Mode(target_versions={black.TargetVersion.PYaa}     ,							line_length=119			)
           snake_case__       :   Tuple	      =    black.format_str(__lowerCamelCase     ,							mode=__lowerCamelCase			)
           snake_case__       :   Union[str, Any]	      =    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 			_lowerCAmelCase      (     self     :					Tuple			):
           snake_case__       :   List[str]	      =    check_copies.find_code_in_transformers('models.bert.modeling_bert.BertLMPredictionHead'			)
           self.assertEqual(__lowerCamelCase     ,							__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					Any			):
           # 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'     ,							__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
           snake_case__       :   Union[str, 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 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           snake_case__       :   List[str]	      =    check_copies.LOCALIZED_READMES['README_zh-hans.md']

           snake_case__       :   List[str]	      =    (
               '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.'
           )
           snake_case__       :   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'
           )
           snake_case__       :   Tuple	      =    (
               '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'
           )

           snake_case__      ,							snake_case__       :   Optional[Any]	      =    check_copies.convert_to_localized_md(
               __lowerCamelCase     ,							__lowerCamelCase     ,							localized_readme['format_model_list']			)

           self.assertFalse(__lowerCamelCase			)
           self.assertEqual(__lowerCamelCase     ,							__lowerCamelCase			)

           snake_case__      ,							snake_case__       :   Any	      =    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			)

           snake_case__       :   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.'
           )
           snake_case__       :   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'
           )
           snake_case__       :   List[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'
           )

           snake_case__      ,							snake_case__       :   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			)
