






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

import black


A__			:    Tuple         =				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__			:    int         =				'    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    _UpperCAmelCase      ( unittest.TestCase			):

				"""simple docstring"""




				def        lowercase__     (  self		:					List[Any]						):

								'''simple docstring'''
								lowercase__     				=    tempfile.mkdtemp()
								os.makedirs(os.path.join(self.transformer_dir,						'''models/bert/'''						)						)
								lowercase__     				=    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        lowercase__     (  self		:					Optional[int]						):

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




				def        lowercase__     (  self		:					Optional[int],						lowerCamelCase		:					str,						lowerCamelCase		:					List[str],						lowerCamelCase		:					Union[str, Any],						lowerCamelCase		:					Union[str, Any]=None						):

								'''simple docstring'''
								lowercase__     				=    comment + F"""\nclass {class_name}(nn.Module):\n""" + class_code
								if overwrite_result is not None:
												lowercase__     				=    comment + F"""\nclass {class_name}(nn.Module):\n""" + overwrite_result
								lowercase__     				=    black.Mode(target_versions={black.TargetVersion.PYaa},						line_length=119						)
								lowercase__     				=    black.format_str(lowerCamelCase,						mode=lowerCamelCase						)
								lowercase__     				=    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        lowercase__     (  self		:					int						):

								'''simple docstring'''
								lowercase__     				=    check_copies.find_code_in_transformers('''models.bert.modeling_bert.BertLMPredictionHead'''						)
								self.assertEqual(lowerCamelCase,						lowerCamelCase						)




				def        lowercase__     (  self		:					Optional[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''',						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
								lowercase__     				=    '''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        lowercase__     (  self		:					Union[str, Any]						):

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

								lowercase__     				=    (
								    '''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.'''
								)
								lowercase__     				=    (
								    '''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'''
								)
								lowercase__     				=    (
								    '''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'''
								)

								lowercase__				,		lowercase__     				=    check_copies.convert_to_localized_md(
								    lowerCamelCase,						lowerCamelCase,						localized_readme['''format_model_list''']						)

								self.assertFalse(lowerCamelCase						)
								self.assertEqual(lowerCamelCase,						lowerCamelCase						)

								lowercase__				,		lowercase__     				=    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						)

								lowercase__     				=    (
								    '''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.'''
								)
								lowercase__     				=    (
								    '''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'''
								)
								lowercase__     				=    (
								    '''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'''
								)

								lowercase__				,		lowercase__     				=    check_copies.convert_to_localized_md(
								    lowerCamelCase,						lowerCamelCase,						localized_readme['''format_model_list''']						)

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












import argparse
import os
import re


A__			:    Optional[int]         =				'src/transformers'

# Pattern that looks at the indentation in a line.
A__			:    Union[str, Any]         =				re.compile(r'^(\s*)\S')
# Pattern that matches `"key":" and puts `key` in group 0.
A__			:    List[str]         =				re.compile(r'^\s*"([^"]+)":')
# Pattern that matches `_import_structure["key"]` and puts `key` in group 0.
A__			:    List[Any]         =				re.compile(r'^\s*_import_structure\["([^"]+)"\]')
# Pattern that matches `"key",` and puts `key` in group 0.
A__			:    int         =				re.compile(r'^\s*"([^"]+)",\s*$')
# Pattern that matches any `[stuff]` and puts `stuff` in group 0.
A__			:    Tuple         =				re.compile(r'\[([^\]]+)\]')






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    _re_indent.search(lowerCamelCase_       )
				return "" if search is None else search.groups()[0]






def 						a    (		lowerCamelCase_	,     lowerCamelCase_=""	,     lowerCamelCase_=None	,     lowerCamelCase_=None       ):






				'''simple docstring'''
				lowercase__     				=    0
				lowercase__     				=    code.split('''\n'''       )
				if start_prompt is not None:
								while not lines[index].startswith(lowerCamelCase_       ):
												index += 1
								lowercase__     				=    ['''\n'''.join(lines[:index]       )]
				else:
								lowercase__     				=    []

				# We split into blocks until we get to the `end_prompt` (or the end of the block).
				lowercase__     				=    [lines[index]]
				index += 1
				while index < len(lowerCamelCase_       ) and (end_prompt is None or not lines[index].startswith(lowerCamelCase_       )):
								if len(lines[index]       ) > 0 and get_indent(lines[index]       ) == indent_level:
												if len(lowerCamelCase_       ) > 0 and get_indent(current_block[-1]       ).startswith(indent_level + ''' '''       ):
																current_block.append(lines[index]       )
																blocks.append('''\n'''.join(lowerCamelCase_       )       )
																if index < len(lowerCamelCase_       ) - 1:
																				lowercase__     				=    [lines[index + 1]]
																				index += 1
																else:
																				lowercase__     				=    []
												else:
																blocks.append('''\n'''.join(lowerCamelCase_       )       )
																lowercase__     				=    [lines[index]]
								else:
												current_block.append(lines[index]       )
								index += 1

				# Adds current block if it's nonempty.
				if len(lowerCamelCase_       ) > 0:
								blocks.append('''\n'''.join(lowerCamelCase_       )       )

				# Add final block after end_prompt if provided.
				if end_prompt is not None and index < len(lowerCamelCase_       ):
								blocks.append('''\n'''.join(lines[index:]       )       )

				return blocks






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''

				def _inner(lowerCamelCase_       ):
								return key(lowerCamelCase_       ).lower().replace('''_'''	,     ''''''       )

				return _inner






def 						a    (		lowerCamelCase_	,     lowerCamelCase_=None       ):






				'''simple docstring'''

				# If no key is provided, we use a noop.
				def noop(lowerCamelCase_       ):
								return x

				if key is None:
								lowercase__     				=    noop
				# Constants are all uppercase, they go first.
				lowercase__     				=    [obj for obj in objects if key(lowerCamelCase_       ).isupper()]
				# Classes are not all uppercase but start with a capital, they go second.
				lowercase__     				=    [obj for obj in objects if key(lowerCamelCase_       )[0].isupper() and not key(lowerCamelCase_       ).isupper()]
				# Functions begin with a lowercase, they go last.
				lowercase__     				=    [obj for obj in objects if not key(lowerCamelCase_       )[0].isupper()]

				lowercase__     				=    ignore_underscore(lowerCamelCase_       )
				return sorted(lowerCamelCase_	,     key=lowerCamelCase_       ) + sorted(lowerCamelCase_	,     key=lowerCamelCase_       ) + sorted(lowerCamelCase_	,     key=lowerCamelCase_       )






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''

				# This inner function sort imports between [ ].
				def _replace(lowerCamelCase_       ):
								lowercase__     				=    match.groups()[0]
								if "," not in imports:
												return F"""[{imports}]"""
								lowercase__     				=    [part.strip().replace('''"'''	,     ''''''       ) for part in imports.split(''','''       )]
								# We will have a final empty element if the line finished with a comma.
								if len(keys[-1]       ) == 0:
												lowercase__     				=    keys[:-1]
								return "[" + ", ".join([F"""\"{k}\"""" for k in sort_objects(lowerCamelCase_       )]       ) + "]"

				lowercase__     				=    import_statement.split('''\n'''       )
				if len(lowerCamelCase_       ) > 3:
								# Here we have to sort internal imports that are on several lines (one per name):
								# key: [
								#     "object1",
								#     "object2",
								#     ...
								# ]

								# We may have to ignore one or two lines on each side.
								lowercase__     				=    2 if lines[1].strip() == '''[''' else 1
								lowercase__     				=    [(i, _re_strip_line.search(lowerCamelCase_       ).groups()[0]) for i, line in enumerate(lines[idx:-idx]       )]
								lowercase__     				=    sort_objects(lowerCamelCase_	,     key=lambda lowerCamelCase_       : x[1]       )
								lowercase__     				=    [lines[x[0] + idx] for x in sorted_indices]
								return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]       )
				elif len(lowerCamelCase_       ) == 3:
								# Here we have to sort internal imports that are on one separate line:
								# key: [
								#     "object1", "object2", ...
								# ]
								if _re_bracket_content.search(lines[1]       ) is not None:
												lowercase__     				=    _re_bracket_content.sub(_replace	,     lines[1]       )
								else:
												lowercase__     				=    [part.strip().replace('''"'''	,     ''''''       ) for part in lines[1].split(''','''       )]
												# We will have a final empty element if the line finished with a comma.
												if len(keys[-1]       ) == 0:
																lowercase__     				=    keys[:-1]
												lowercase__     				=    get_indent(lines[1]       ) + ''', '''.join([F"""\"{k}\"""" for k in sort_objects(lowerCamelCase_       )]       )
								return "\n".join(lowerCamelCase_       )
				else:
								# Finally we have to deal with imports fitting on one line
								lowercase__     				=    _re_bracket_content.sub(_replace	,     lowerCamelCase_       )
								return import_statement






def 						a    (		lowerCamelCase_	,     lowerCamelCase_=True       ):






				'''simple docstring'''
				with open(lowerCamelCase_	,     encoding='''utf-8'''       ) as f:
								lowercase__     				=    f.read()

				if "_import_structure" not in code:
								return

				# Blocks of indent level 0
				lowercase__     				=    split_code_in_indented_blocks(
				    lowerCamelCase_	,     start_prompt='''_import_structure = {'''	,     end_prompt='''if TYPE_CHECKING:'''       )

				# We ignore block 0 (everything untils start_prompt) and the last block (everything after end_prompt).
				for block_idx in range(1	,     len(lowerCamelCase_       ) - 1       ):
								# Check if the block contains some `_import_structure`s thingy to sort.
								lowercase__     				=    main_blocks[block_idx]
								lowercase__     				=    block.split('''\n'''       )

								# Get to the start of the imports.
								lowercase__     				=    0
								while line_idx < len(lowerCamelCase_       ) and "_import_structure" not in block_lines[line_idx]:
												# Skip dummy import blocks
												if "import dummy" in block_lines[line_idx]:
																lowercase__     				=    len(lowerCamelCase_       )
												else:
																line_idx += 1
								if line_idx >= len(lowerCamelCase_       ):
												continue

								# Ignore beginning and last line: they don't contain anything.
								lowercase__     				=    '''\n'''.join(block_lines[line_idx:-1]       )
								lowercase__     				=    get_indent(block_lines[1]       )
								# Slit the internal block into blocks of indent level 1.
								lowercase__     				=    split_code_in_indented_blocks(lowerCamelCase_	,     indent_level=lowerCamelCase_       )
								# We have two categories of import key: list or _import_structure[key].append/extend
								lowercase__     				=    _re_direct_key if '''_import_structure = {''' in block_lines[0] else _re_indirect_key
								# Grab the keys, but there is a trap: some lines are empty or just comments.
								lowercase__     				=    [(pattern.search(lowerCamelCase_       ).groups()[0] if pattern.search(lowerCamelCase_       ) is not None else None) for b in internal_blocks]
								# We only sort the lines with a key.
								lowercase__     				=    [(i, key) for i, key in enumerate(lowerCamelCase_       ) if key is not None]
								lowercase__     				=    [x[0] for x in sorted(lowerCamelCase_	,     key=lambda lowerCamelCase_       : x[1]       )]

								# We reorder the blocks by leaving empty lines/comments as they were and reorder the rest.
								lowercase__     				=    0
								lowercase__     				=    []
								for i in range(len(lowerCamelCase_       )       ):
												if keys[i] is None:
																reorderded_blocks.append(internal_blocks[i]       )
												else:
																lowercase__     				=    sort_objects_in_import(internal_blocks[sorted_indices[count]]       )
																reorderded_blocks.append(lowerCamelCase_       )
																count += 1

        # And we put our main block back together with its first and last line.
								lowercase__     				=    '''\n'''.join(block_lines[:line_idx] + reorderded_blocks + [block_lines[-1]]       )

				if code != "\n".join(lowerCamelCase_       ):
								if check_only:
												return True
								else:
												print(F"""Overwriting {file}."""       )
												with open(lowerCamelCase_	,     '''w'''	,     encoding='''utf-8'''       ) as f:
																f.write('''\n'''.join(lowerCamelCase_       )       )






def 						a    (		lowerCamelCase_=True       ):






				'''simple docstring'''
				lowercase__     				=    []
				for root, _, files in os.walk(lowerCamelCase_       ):
								if "__init__.py" in files:
												lowercase__     				=    sort_imports(os.path.join(lowerCamelCase_	,     '''__init__.py'''       )	,     check_only=lowerCamelCase_       )
												if result:
																lowercase__     				=    [os.path.join(lowerCamelCase_	,     '''__init__.py'''       )]
				if len(lowerCamelCase_       ) > 0:
								raise ValueError(F"""Would overwrite {len(lowerCamelCase_       )} files, run `make style`."""       )


if __name__ == "__main__":
							A__			:    str         =				argparse.ArgumentParser()
							parser.add_argument('--check_only', action='store_true', help='Whether to only check or fix style.')
							A__			:    int         =				parser.parse_args()

							sort_imports_in_all_inits(check_only=args.check_only)




