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

import black


__magic_name__								=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.
__magic_name__								='''    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     _A   (    unittest.TestCase							):


  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      tempfile.mkdtemp()
       os.makedirs(os.path.join(self.transformer_dir   ,				'''models/bert/'''	)	)
       UpperCamelCase__										=      self.transformer_dir
       shutil.copy(
           os.path.join(SCREAMING_SNAKE_CASE_   ,				'''src/transformers/models/bert/modeling_bert.py'''	)   ,				os.path.join(self.transformer_dir   ,				'''models/bert/modeling_bert.py'''	)   ,				)


  def 		_a					(self	)		->      Dict:





       '''simple docstring'''





       UpperCamelCase__										=      '''src/transformers'''
       shutil.rmtree(self.transformer_dir	)


  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_=None	)		->      Tuple:





       '''simple docstring'''





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


  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      check_copies.find_code_in_transformers('''models.bert.modeling_bert.BertLMPredictionHead'''	)
       self.assertEqual(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)


  def 		_a					(self	)		->      Optional[int]:





       '''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'''   ,				SCREAMING_SNAKE_CASE_   ,				)

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

       # Copy consistency with a really long name
       UpperCamelCase__										=      '''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'''   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)   ,				)

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





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





       '''simple docstring'''





       UpperCamelCase__										=      check_copies.LOCALIZED_READMES['''README_zh-hans.md''']

       UpperCamelCase__										=      (
           '''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__										=      (
           '''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__										=      (
           '''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__						,       UpperCamelCase__										=      check_copies.convert_to_localized_md(
           SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				localized_readme['''format_model_list''']	)

       self.assertFalse(SCREAMING_SNAKE_CASE_	)
       self.assertEqual(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__						,       UpperCamelCase__										=      check_copies.convert_to_localized_md(
           SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				localized_readme['''format_model_list''']	)

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

       UpperCamelCase__										=      (
           '''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__										=      (
           '''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__										=      (
           '''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__						,       UpperCamelCase__										=      check_copies.convert_to_localized_md(
           SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				localized_readme['''format_model_list''']	)

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




from __future__ import annotations







def  __UpperCamelCase    (						A ,							A							):
     UpperCamelCase__										=      get_failure_array(A							)

     # 2) Step through text searching for pattern
     UpperCamelCase__						,       UpperCamelCase__										=      0, 0  # index into text, pattern
     while i < len(A							):
          if pattern[j] == text[i]:
               if j == (len(A							) - 1):
                    return True
               j += 1

          # if this is a prefix in our pattern
          # just go back far enough to continue
          elif j > 0:
               UpperCamelCase__										=      failure[j - 1]
               continue
          i += 1
     return False







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      [0]
     UpperCamelCase__										=      0
     UpperCamelCase__										=      1
     while j < len(A							):
          if pattern[i] == pattern[j]:
               i += 1
          elif i > 0:
               UpperCamelCase__										=      failure[i - 1]
               continue
          j += 1
          failure.append(A							)
     return failure


if __name__ == "__main__":
     # Test 1)
     __magic_name__								='''abc1abc12'''
     __magic_name__								='''alskfjaldsabc1abc1abc12k23adsfabcabc'''
     __magic_name__								='''alskfjaldsk23adsfabcabc'''
     assert kmp(pattern, texta) and not kmp(pattern, texta)

     # Test 2)
     __magic_name__								='''ABABX'''
     __magic_name__								='''ABABZABABYABABX'''
     assert kmp(pattern, text)

     # Test 3)
     __magic_name__								='''AAAB'''
     __magic_name__								='''ABAAAAAB'''
     assert kmp(pattern, text)

     # Test 4)
     __magic_name__								='''abcdabcy'''
     __magic_name__								='''abcxabcdabxabcdabcdabcy'''
     assert kmp(pattern, text)

     # Test 5)
     __magic_name__								='''aabaabaaa'''
     assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]



