



"""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):
        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):







						"""simple docstring"""







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					tempfile.mkdtemp()
											os.makedirs(os.path.join(self.transformer_dir   ,		"""models/bert/"""       )       )
											snake_case_					:		str 					=					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       ):
											snake_case_					:		Optional[Any] 					=					"""src/transformers"""
											shutil.rmtree(self.transformer_dir       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__   ,		lowercase__=None       ):
											snake_case_					:		Optional[Any] 					=					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_					:		str 					=					black.Mode(target_versions={black.TargetVersion.PYaa}   ,		line_length=1_19       )
											snake_case_					:		Optional[int] 					=					black.format_str(lowercase__   ,		mode=lowercase__       )
											snake_case_					:		Any 					=					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       ):
											snake_case_					:		Optional[Any] 					=					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
											snake_case_					:		List[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"""   ,		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       ):
											snake_case_					:		List[Any] 					=					check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

											snake_case_					:		List[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.\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_					:		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"""
											)
											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_					:		Any 					=					check_copies.convert_to_localized_md(
											    lowercase__   ,		lowercase__   ,		localized_readme["""format_model_list"""]       )

											self.assertFalse(lowercase__       )
											self.assertEqual(lowercase__   ,		lowercase__       )

											snake_case_					,			snake_case_					:		Tuple 					=					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__       )

											snake_case_					:		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."""
											)
											snake_case_					:		Union[str, Any] 					=					(
											    """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_					:		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_					:		Dict 					=					check_copies.convert_to_localized_md(
											    lowercase__   ,		lowercase__   ,		localized_readme["""format_model_list"""]       )

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









"""simple docstring"""

from copy import deepcopy







class    __lowercase     :







						"""simple docstring"""







						def __init__(self   ,		lowercase__ = None   ,		lowercase__ = None       ):

											if arr is None and size is not None:
																snake_case_					:		str 					=					size
																snake_case_					:		Optional[Any] 					=					[0] * size
											elif arr is not None:
																self.init(lowercase__       )
											else:
																raise ValueError("""Either arr or size must be specified"""       )







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											snake_case_					:		Optional[Any] 					=					len(lowercase__       )
											snake_case_					:		int 					=					deepcopy(lowercase__       )
											for i in range(1   ,		self.size       ):
																snake_case_					:		Optional[Any] 					=					self.next_(lowercase__       )
																if j < self.size:
																					self.tree[j] += self.tree[i]







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					self.tree[:]
											for i in range(self.size - 1   ,		0   ,		-1       ):
																snake_case_					:		Optional[int] 					=					self.next_(lowercase__       )
																if j < self.size:
																					arr[j] -= arr[i]
											return arr







						@staticmethod
						def 						__UpperCamelCase							(lowercase__       ):
											return index + (index & (-index))







						@staticmethod
						def 						__UpperCamelCase							(lowercase__       ):
											return index - (index & (-index))







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											if index == 0:
																self.tree[0] += value
																return
											while index < self.size:
																self.tree[index] += value
																snake_case_					:		Tuple 					=					self.next_(lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											self.add(lowercase__   ,		value - self.get(lowercase__       )       )







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											if right == 0:
																return 0
											snake_case_					:		List[str] 					=					self.tree[0]
											right -= 1  # make right inclusive
											while right > 0:
																result += self.tree[right]
																snake_case_					:		Optional[int] 					=					self.prev(lowercase__       )
											return result







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											return self.prefix(lowercase__       ) - self.prefix(lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											return self.query(lowercase__   ,		index + 1       )







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											value -= self.tree[0]
											if value < 0:
																return -1

											snake_case_					:		Tuple 					=					1  # Largest power of 2 <= size
											while j * 2 < self.size:
																j *= 2

											snake_case_					:		Tuple 					=					0

											while j > 0:
																if i + j < self.size and self.tree[i + j] <= value:
																					value -= self.tree[i + j]
																					i += j
																j //= 2
											return i


if __name__ == "__main__":
			import doctest

			doctest.testmod()




