





"""simple docstring"""
import os
import re
import shutil
import sys
import tempfile
import unittest

import black


__UpperCamelCase     :						str						       =  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       a							(   unittest.TestCase  ):



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case=None     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= check_copies.find_code_in_transformers('models.bert.modeling_bert.BertLMPredictionHead'     )
  self.assertEqual(_snake_case				,       _snake_case     )



 def    UpperCamelCase__  (     self     ):







  """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'				,       _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'				,       _snake_case     )				,       )

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

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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

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

  self.assertFalse(_snake_case     )
  self.assertEqual(_snake_case				,       _snake_case     )

  lowerCAmelCase				,lowerCAmelCase    				= check_copies.convert_to_localized_md(
      _snake_case				,       _snake_case				,       localized_readme['format_model_list']     )

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

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

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












"""simple docstring"""
from typing import Any







class       a							:



 def __init__(     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= data
  lowerCAmelCase    				= None



 def __repr__(     self     ):







  """simple docstring"""






  return F'Node({self.data})'







class       a							:



 def __init__(     self     ):







  """simple docstring"""






  lowerCAmelCase    				= None



 def __iter__(     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.head
  while node:
   yield node.data
   lowerCAmelCase    				= node.next



 def __len__(     self     ):







  """simple docstring"""






  return sum(1 for _ in self     )



 def __repr__(     self     ):







  """simple docstring"""






  return "->".join([str(_snake_case     ) for item in self]     )



 def __getitem__(     self				,       _snake_case     ):







  """simple docstring"""






  if not 0 <= index < len(self     ):
   raise ValueError('list index out of range.'     )
  for i, node in enumerate(self     ):
   if i == index:
    return node
  return None



 def __setitem__(     self				,       _snake_case				,       _snake_case     ):







  """simple docstring"""






  if not 0 <= index < len(self     ):
   raise ValueError('list index out of range.'     )
  lowerCAmelCase    				= self.head
  for _ in range(_snake_case     ):
   lowerCAmelCase    				= current.next
  lowerCAmelCase    				= data



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  self.insert_nth(len(self     )				,       _snake_case     )



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  self.insert_nth(0				,       _snake_case     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case     ):







  """simple docstring"""






  if not 0 <= index <= len(self     ):
   raise IndexError('list index out of range'     )
  lowerCAmelCase    				= Node(_snake_case     )
  if self.head is None:
   lowerCAmelCase    				= new_node
  elif index == 0:
   lowerCAmelCase    				= self.head  # link new_node to head
   lowerCAmelCase    				= new_node
  else:
   lowerCAmelCase    				= self.head
   for _ in range(index - 1     ):
    lowerCAmelCase    				= temp.next
   lowerCAmelCase    				= temp.next
   lowerCAmelCase    				= new_node



 def    UpperCamelCase__  (     self     ):  # print every node data







  """simple docstring"""






  print(self     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return self.delete_nth(0     )



 def    UpperCamelCase__  (     self     ):  # delete from tail







  """simple docstring"""






  return self.delete_nth(len(self     ) - 1     )



 def    UpperCamelCase__  (     self				,       _snake_case = 0     ):







  """simple docstring"""






  if not 0 <= index <= len(self     ) - 1:  # test if index is valid
   raise IndexError('List index out of range.'     )
  lowerCAmelCase    				= self.head  # default first node
  if index == 0:
   lowerCAmelCase    				= self.head.next
  else:
   lowerCAmelCase    				= self.head
   for _ in range(index - 1     ):
    lowerCAmelCase    				= temp.next
   lowerCAmelCase    				= temp.next
   lowerCAmelCase    				= temp.next.next
  return delete_node.data



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return self.head is None



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= None
  lowerCAmelCase    				= self.head

  while current:
   # Store the current node's next node.
   lowerCAmelCase    				= current.next
   # Make the current node's next point backwards
   lowerCAmelCase    				= prev
   # Make the previous node be the current node
   lowerCAmelCase    				= current
   # Make the current node the next node (to progress iteration)
   lowerCAmelCase    				= next_node
  # Return prev in order to put the head at the end
  lowerCAmelCase    				= prev


def 		_SCREAMING_SNAKE_CASE			():
 lowerCAmelCase    				= LinkedList()
 assert linked_list.is_empty() is True
 assert str(_UpperCAmelCase			) == ""

 try:
  linked_list.delete_head()
  raise AssertionError  # This should not happen.
 except IndexError:
  assert True  # This should happen.

 try:
  linked_list.delete_tail()
  raise AssertionError  # This should not happen.
 except IndexError:
  assert True  # This should happen.

 for i in range(10			):
  assert len(_UpperCAmelCase			) == i
  linked_list.insert_nth(_UpperCAmelCase  ,     i + 1			)
 assert str(_UpperCAmelCase			) == "->".join(str(_UpperCAmelCase			) for i in range(1  ,     11			)			)

 linked_list.insert_head(0			)
 linked_list.insert_tail(11			)
 assert str(_UpperCAmelCase			) == "->".join(str(_UpperCAmelCase			) for i in range(0  ,     12			)			)

 assert linked_list.delete_head() == 0
 assert linked_list.delete_nth(9			) == 10
 assert linked_list.delete_tail() == 11
 assert len(_UpperCAmelCase			) == 9
 assert str(_UpperCAmelCase			) == "->".join(str(_UpperCAmelCase			) for i in range(1  ,     10			)			)

 assert all(linked_list[i] == i + 1 for i in range(0  ,     9			)			) is True

 for i in range(0  ,     9			):
  lowerCAmelCase    				= -i
 assert all(linked_list[i] == -i for i in range(0  ,     9			)			) is True

 linked_list.reverse()
 assert str(_UpperCAmelCase			) == "->".join(str(_UpperCAmelCase			) for i in range(-8  ,     1			)			)

def 		_SCREAMING_SNAKE_CASE			():
 lowerCAmelCase    				= [
     -9,
     100,
     Node(7734_5112			),
     'dlrow olleH',
     7,
     5555,
     0,
     -192.5_5555,
     'Hello, world!',
     77.9,
     Node(10			),
     None,
     None,
     12.20,
 ]
 lowerCAmelCase    				= LinkedList()

 for i in test_input:
  linked_list.insert_tail(_UpperCAmelCase			)

 # Check if it's empty or not
 assert linked_list.is_empty() is False
 assert (
     str(_UpperCAmelCase			) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
     "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
 )

 # Delete the head
 lowerCAmelCase    				= linked_list.delete_head()
 assert result == -9
 assert (
     str(_UpperCAmelCase			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None->None->12.2"
 )

 # Delete the tail
 lowerCAmelCase    				= linked_list.delete_tail()
 assert result == 12.2
 assert (
     str(_UpperCAmelCase			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None->None"
 )

 # Delete a node in specific location in linked list
 lowerCAmelCase    				= linked_list.delete_nth(10			)
 assert result is None
 assert (
     str(_UpperCAmelCase			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
     "Hello, world!->77.9->Node(10)->None"
 )

 # Add a Node instance to its head
 linked_list.insert_head(Node('Hello again, world!'			)			)
 assert (
     str(_UpperCAmelCase			)
     == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
     "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
 )

 # Add None to its tail
 linked_list.insert_tail(_UpperCAmelCase			)
 assert (
     str(_UpperCAmelCase			)
     == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
     "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
 )

 # Reverse the linked list
 linked_list.reverse()
 assert (
     str(_UpperCAmelCase			)
     == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
     "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
 )

def 		_SCREAMING_SNAKE_CASE			():
 from doctest import testmod

 testmod()

 lowerCAmelCase    				= LinkedList()
 linked_list.insert_head(input('Inserting 1st at head '			).strip()			)
 linked_list.insert_head(input('Inserting 2nd at head '			).strip()			)
 print('\nPrint list:'			)
 linked_list.print_list()
 linked_list.insert_tail(input('\nInserting 1st at tail '			).strip()			)
 linked_list.insert_tail(input('Inserting 2nd at tail '			).strip()			)
 print('\nPrint list:'			)
 linked_list.print_list()
 print('\nDelete head'			)
 linked_list.delete_head()
 print('Delete tail'			)
 linked_list.delete_tail()
 print('\nPrint list:'			)
 linked_list.print_list()
 print('\nReverse linked list'			)
 linked_list.reverse()
 print('\nPrint list:'			)
 linked_list.print_list()
 print('\nString representation of linked list:'			)
 print(_UpperCAmelCase			)
 print('\nReading/changing Node data using indexing:'			)
 print(F'Element at Position 1: {linked_list[1]}'			)
 lowerCAmelCase    				= input('Enter New Value: '			).strip()
 print('New list:'			)
 print(_UpperCAmelCase			)
 print(F'length of linked_list is : {len(_UpperCAmelCase			)}'			)


if __name__ == "__main__":
       main()





