


'''simple docstring'''






from typing import Any






class    __magic_name__				:






       def __init__(     self    ,				snake_case)		->    Tuple:




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =data
          _UpperCAmelCase  :  Optional[int]				       =None






       def __repr__(     self)		->    str:




          '''simple docstring'''
          return f"Node({self.data})"






class    __magic_name__				:






       def __init__(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =None






       def __iter__(     self)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  List[Any]				       =self.head
          while node:
             yield node.data
             _UpperCAmelCase  :  Tuple				       =node.next






       def __len__(     self)		->    int:




          '''simple docstring'''
          return sum(1 for _ in self)






       def __repr__(     self)		->    str:




          '''simple docstring'''
          return "->".join([str(snake_case) for item in self])






       def __getitem__(     self    ,				snake_case)		->    Any:




          '''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)		->    None:




          '''simple docstring'''
          if not 0 <= index < len(self):
             raise ValueError('list index out of range.')
          _UpperCAmelCase  :  Optional[Any]				       =self.head
          for _ in range(snake_case):
             _UpperCAmelCase  :  List[str]				       =current.next
          _UpperCAmelCase  :  Union[str, Any]				       =data






       def      lowerCAmelCase						(     self    ,				snake_case)		->    None:




          '''simple docstring'''
          self.insert_nth(len(self)    ,				snake_case)






       def      lowerCAmelCase						(     self    ,				snake_case)		->    None:




          '''simple docstring'''
          self.insert_nth(0    ,				snake_case)






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case)		->    None:




          '''simple docstring'''
          if not 0 <= index <= len(self):
             raise IndexError('list index out of range')
          _UpperCAmelCase  :  Union[str, Any]				       =Node(snake_case)
          if self.head is None:
             _UpperCAmelCase  :  Union[str, Any]				       =new_node
          elif index == 0:
             _UpperCAmelCase  :  Any				       =self.head  # link new_node to head
             _UpperCAmelCase  :  int				       =new_node
          else:
             _UpperCAmelCase  :  Tuple				       =self.head
             for _ in range(index - 1):
                _UpperCAmelCase  :  Any				       =temp.next
             _UpperCAmelCase  :  Any				       =temp.next
             _UpperCAmelCase  :  Any				       =new_node






       def      lowerCAmelCase						(     self)		->    None:  # print every node data




          '''simple docstring'''
          print(self)






       def      lowerCAmelCase						(     self)		->    Any:




          '''simple docstring'''
          return self.delete_nth(0)






       def      lowerCAmelCase						(     self)		->    Any:  # delete from tail




          '''simple docstring'''
          return self.delete_nth(len(self) - 1)






       def      lowerCAmelCase						(     self    ,				snake_case = 0)		->    Any:




          '''simple docstring'''
          if not 0 <= index <= len(self) - 1:  # test if index is valid
             raise IndexError('List index out of range.')
          _UpperCAmelCase  :  Optional[Any]				       =self.head  # default first node
          if index == 0:
             _UpperCAmelCase  :  Dict				       =self.head.next
          else:
             _UpperCAmelCase  :  int				       =self.head
             for _ in range(index - 1):
                _UpperCAmelCase  :  Optional[Any]				       =temp.next
             _UpperCAmelCase  :  Any				       =temp.next
             _UpperCAmelCase  :  Optional[int]				       =temp.next.next
          return delete_node.data






       def      lowerCAmelCase						(     self)		->    bool:




          '''simple docstring'''
          return self.head is None






       def      lowerCAmelCase						(     self)		->    None:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =None
          _UpperCAmelCase  :  str				       =self.head

          while current:
             # Store the current node's next node.
             _UpperCAmelCase  :  int				       =current.next
             # Make the current node's next point backwards
             _UpperCAmelCase  :  Union[str, Any]				       =prev
             # Make the previous node be the current node
             _UpperCAmelCase  :  Optional[int]				       =current
             # Make the current node the next node (to progress iteration)
             _UpperCAmelCase  :  int				       =next_node
          # Return prev in order to put the head at the end
          _UpperCAmelCase  :  Union[str, Any]				       =prev






def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  Optional[int]				       =LinkedList()
   assert linked_list.is_empty() is True
   assert str(__lowerCamelCase				) == ""

   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(1_0				):
      assert len(__lowerCamelCase				) == i
      linked_list.insert_nth(__lowerCamelCase			,       i + 1				)
   assert str(__lowerCamelCase				) == "->".join(str(__lowerCamelCase				) for i in range(1			,       1_1				)				)

   linked_list.insert_head(0				)
   linked_list.insert_tail(1_1				)
   assert str(__lowerCamelCase				) == "->".join(str(__lowerCamelCase				) for i in range(0			,       1_2				)				)

   assert linked_list.delete_head() == 0
   assert linked_list.delete_nth(9				) == 1_0
   assert linked_list.delete_tail() == 1_1
   assert len(__lowerCamelCase				) == 9
   assert str(__lowerCamelCase				) == "->".join(str(__lowerCamelCase				) for i in range(1			,       1_0				)				)

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

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

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





def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  List[Any]				       =[
       -9,
       1_0_0,
       Node(7_7_3_4_5_1_1_2				),
       'dlrow olleH',
       7,
       5_5_5_5,
       0,
       -1_92.5_55_55,
       'Hello, world!',
       77.9,
       Node(1_0				),
       None,
       None,
       12.20,
   ]
   _UpperCAmelCase  :  Tuple				       =LinkedList()

   for i in test_input:
      linked_list.insert_tail(__lowerCamelCase				)

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

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

   # Delete the tail
   _UpperCAmelCase  :  str				       =linked_list.delete_tail()
   assert result == 12.2
   assert (
       str(__lowerCamelCase				) == "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
   _UpperCAmelCase  :  Dict				       =linked_list.delete_nth(1_0				)
   assert result is None
   assert (
       str(__lowerCamelCase				) == "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(__lowerCamelCase				)
       == "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(__lowerCamelCase				)
   assert (
       str(__lowerCamelCase				)
       == "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(__lowerCamelCase				)
       == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
       "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
   )





def lowerCamelCase__     (		):







   '''simple docstring'''




   from doctest import testmod

   testmod()

   _UpperCAmelCase  :  Union[str, Any]				       =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(__lowerCamelCase				)
   print('\nReading/changing Node data using indexing:'				)
   print(f"Element at Position 1: {linked_list[1]}"				)
   _UpperCAmelCase  :  int				       =input('Enter New Value: '				).strip()
   print('New list:'				)
   print(__lowerCamelCase				)
   print(f"length of linked_list is : {len(__lowerCamelCase				)}"				)


if __name__ == "__main__":
 main()





'''simple docstring'''






import json
import os
import re
import unittest

from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class    __magic_name__				(						lowerCAmelCase   ,unittest.TestCase							):
       UpperCAmelCase		 =CodeGenTokenizer
       UpperCAmelCase		 =CodeGenTokenizerFast
       UpperCAmelCase		 =True
       UpperCAmelCase		 ={"add_prefix_space": True}
       UpperCAmelCase		 =False






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




          '''simple docstring'''
          super().setUp()

          # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
          _UpperCAmelCase  :  Optional[Any]				       =[
              'l',
              'o',
              'w',
              'e',
              'r',
              's',
              't',
              'i',
              'd',
              'n',
              '\u0120',
              '\u0120l',
              '\u0120n',
              '\u0120lo',
              '\u0120low',
              'er',
              '\u0120lowest',
              '\u0120newer',
              '\u0120wider',
              '<unk>',
              '<|endoftext|>',
          ]
          _UpperCAmelCase  :  Dict				       =dict(zip(snake_case    ,				range(len(snake_case))))
          _UpperCAmelCase  :  List[Any]				       =['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
          _UpperCAmelCase  :  List[Any]				       ={'unk_token': '<unk>'}

          _UpperCAmelCase  :  List[Any]				       =os.path.join(self.tmpdirname    ,				VOCAB_FILES_NAMES['vocab_file'])
          _UpperCAmelCase  :  List[str]				       =os.path.join(self.tmpdirname    ,				VOCAB_FILES_NAMES['merges_file'])
          with open(self.vocab_file    ,				'w'    ,				encoding='utf-8') as fp:
             fp.write(json.dumps(snake_case) + '\n')
          with open(self.merges_file    ,				'w'    ,				encoding='utf-8') as fp:
             fp.write('\n'.join(snake_case))






       def      lowerCAmelCase						(     self    ,				**snake_case)		->    str:




          '''simple docstring'''
          kwargs.update(self.special_tokens_map)
          return CodeGenTokenizer.from_pretrained(self.tmpdirname    ,				**snake_case)






       def      lowerCAmelCase						(     self    ,				**snake_case)		->    Optional[Any]:




          '''simple docstring'''
          kwargs.update(self.special_tokens_map)
          return CodeGenTokenizerFast.from_pretrained(self.tmpdirname    ,				**snake_case)






       def      lowerCAmelCase						(     self    ,				snake_case)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Union[str, Any]				       ='lower newer'
          _UpperCAmelCase  :  int				       ='lower newer'
          return input_text, output_text






       def      lowerCAmelCase						(     self)		->    int:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =CodeGenTokenizer(self.vocab_file    ,				self.merges_file    ,				**self.special_tokens_map)
          _UpperCAmelCase  :  str				       ='lower newer'
          _UpperCAmelCase  :  Union[str, Any]				       =['\u0120low', 'er', '\u0120', 'n', 'e', 'w', 'er']
          _UpperCAmelCase  :  Any				       =tokenizer.tokenize(snake_case    ,				add_prefix_space=snake_case)
          self.assertListEqual(snake_case    ,				snake_case)

          _UpperCAmelCase  :  Any				       =tokens + [tokenizer.unk_token]
          _UpperCAmelCase  :  List[str]				       =[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
          self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case)    ,				snake_case)






       def      lowerCAmelCase						(     self)		->    Union[str, Any]:




          '''simple docstring'''
          if not self.test_rust_tokenizer:
             return

          _UpperCAmelCase  :  Tuple				       =self.get_tokenizer()
          _UpperCAmelCase  :  Dict				       =self.get_rust_tokenizer(add_prefix_space=snake_case)

          _UpperCAmelCase  :  Union[str, Any]				       ='lower newer'

          # Testing tokenization
          _UpperCAmelCase  :  List[str]				       =tokenizer.tokenize(snake_case    ,				add_prefix_space=snake_case)
          _UpperCAmelCase  :  Optional[int]				       =rust_tokenizer.tokenize(snake_case)
          self.assertListEqual(snake_case    ,				snake_case)

          # Testing conversion to ids without special tokens
          _UpperCAmelCase  :  str				       =tokenizer.encode(snake_case    ,				add_special_tokens=snake_case    ,				add_prefix_space=snake_case)
          _UpperCAmelCase  :  Optional[int]				       =rust_tokenizer.encode(snake_case    ,				add_special_tokens=snake_case)
          self.assertListEqual(snake_case    ,				snake_case)

          # Testing conversion to ids with special tokens
          _UpperCAmelCase  :  Dict				       =self.get_rust_tokenizer(add_prefix_space=snake_case)
          _UpperCAmelCase  :  Tuple				       =tokenizer.encode(snake_case    ,				add_prefix_space=snake_case)
          _UpperCAmelCase  :  int				       =rust_tokenizer.encode(snake_case)
          self.assertListEqual(snake_case    ,				snake_case)

          # Testing the unknown token
          _UpperCAmelCase  :  List[str]				       =tokens + [rust_tokenizer.unk_token]
          _UpperCAmelCase  :  Union[str, Any]				       =[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
          self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(snake_case)    ,				snake_case)






       def      lowerCAmelCase						(     self    ,				*snake_case    ,				**snake_case)		->    Any:




          '''simple docstring'''
          # It's very difficult to mix/test pretokenization with byte-level
          # And get both CodeGen and Roberta to work at the same time (mostly an issue of adding a space before the string)
          pass






       def      lowerCAmelCase						(     self    ,				snake_case=1_5)		->    Optional[int]:




          '''simple docstring'''
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"):
                _UpperCAmelCase  :  Optional[Any]				       =self.rust_tokenizer_class.from_pretrained(snake_case    ,				**snake_case)

                # Simple input
                _UpperCAmelCase  :  List[str]				       ='This is a simple input'
                _UpperCAmelCase  :  Optional[Any]				       =['This is a simple input 1', 'This is a simple input 2']
                _UpperCAmelCase  :  int				       =('This is a simple input', 'This is a pair')
                _UpperCAmelCase  :  Union[str, Any]				       =[
                    ('This is a simple input 1', 'This is a simple input 2'),
                    ('This is a simple pair 1', 'This is a simple pair 2'),
                ]

                # Simple input tests
                self.assertRaises(snake_case    ,				tokenizer_r.encode    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length')

                # Simple input
                self.assertRaises(snake_case    ,				tokenizer_r.encode_plus    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length')

                # Simple input
                self.assertRaises(
                    snake_case    ,				tokenizer_r.batch_encode_plus    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length'    ,				)

                # Pair input
                self.assertRaises(snake_case    ,				tokenizer_r.encode    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length')

                # Pair input
                self.assertRaises(snake_case    ,				tokenizer_r.encode_plus    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length')

                # Pair input
                self.assertRaises(
                    snake_case    ,				tokenizer_r.batch_encode_plus    ,				snake_case    ,				max_length=snake_case    ,				padding='max_length'    ,				)






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




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       =CodeGenTokenizer.from_pretrained(self.tmpdirname    ,				pad_token='<pad>')

          # Simple input
          _UpperCAmelCase  :  List[Any]				       ='This is a simple input'
          _UpperCAmelCase  :  Any				       =['This is a simple input looooooooong', 'This is a simple input']
          _UpperCAmelCase  :  List[str]				       =('This is a simple input', 'This is a pair')
          _UpperCAmelCase  :  Optional[int]				       =[
              ('This is a simple input loooooong', 'This is a simple input'),
              ('This is a simple pair loooooong', 'This is a simple pair'),
          ]

          _UpperCAmelCase  :  List[Any]				       =tokenizer.pad_token_id

          _UpperCAmelCase  :  Union[str, Any]				       =tokenizer(snake_case    ,				padding='max_length'    ,				max_length=3_0    ,				return_tensors='np')
          _UpperCAmelCase  :  List[Any]				       =tokenizer(snake_case    ,				padding=snake_case    ,				truncate=snake_case    ,				return_tensors='np')
          _UpperCAmelCase  :  Optional[Any]				       =tokenizer(*snake_case    ,				padding='max_length'    ,				max_length=6_0    ,				return_tensors='np')
          _UpperCAmelCase  :  List[Any]				       =tokenizer(snake_case    ,				padding=snake_case    ,				truncate=snake_case    ,				return_tensors='np')

          # s
          # test single string max_length padding
          self.assertEqual(out_s['input_ids'].shape[-1]    ,				3_0)
          self.assertTrue(pad_token_id in out_s['input_ids'])
          self.assertTrue(0 in out_s['attention_mask'])

          # s2
          # test automatic padding
          self.assertEqual(out_sa['input_ids'].shape[-1]    ,				3_3)
          # long slice doesn't have padding
          self.assertFalse(pad_token_id in out_sa['input_ids'][0])
          self.assertFalse(0 in out_sa['attention_mask'][0])
          # short slice does have padding
          self.assertTrue(pad_token_id in out_sa['input_ids'][1])
          self.assertTrue(0 in out_sa['attention_mask'][1])

          # p
          # test single pair max_length padding
          self.assertEqual(out_p['input_ids'].shape[-1]    ,				6_0)
          self.assertTrue(pad_token_id in out_p['input_ids'])
          self.assertTrue(0 in out_p['attention_mask'])

          # p2
          # test automatic padding pair
          self.assertEqual(out_pa['input_ids'].shape[-1]    ,				5_2)
          # long slice pair doesn't have padding
          self.assertFalse(pad_token_id in out_pa['input_ids'][0])
          self.assertFalse(0 in out_pa['attention_mask'][0])
          # short slice pair does have padding
          self.assertTrue(pad_token_id in out_pa['input_ids'][1])
          self.assertTrue(0 in out_pa['attention_mask'][1])






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




          '''simple docstring'''
          _UpperCAmelCase  :  Any				       ='$$$'
          _UpperCAmelCase  :  Any				       =CodeGenTokenizer.from_pretrained(self.tmpdirname    ,				bos_token=snake_case    ,				add_bos_token=snake_case)

          _UpperCAmelCase  :  Optional[Any]				       ='This is a simple input'
          _UpperCAmelCase  :  Any				       =['This is a simple input 1', 'This is a simple input 2']

          _UpperCAmelCase  :  int				       =tokenizer.bos_token_id

          _UpperCAmelCase  :  Optional[Any]				       =tokenizer(snake_case)
          _UpperCAmelCase  :  Tuple				       =tokenizer(snake_case)

          self.assertEqual(out_s.input_ids[0]    ,				snake_case)
          self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids))

          _UpperCAmelCase  :  Optional[int]				       =tokenizer.decode(out_s.input_ids)
          _UpperCAmelCase  :  Any				       =tokenizer.batch_decode(out_sa.input_ids)

          self.assertEqual(decode_s.split()[0]    ,				snake_case)
          self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa))






       @slow
       def      lowerCAmelCase						(     self)		->    Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =CodeGenTokenizer.from_pretrained('Salesforce/codegen-350M-mono')

          _UpperCAmelCase  :  Optional[Any]				       ='\nif len_a > len_b:\n    result = a\nelse:\n    result = b\n\n\n\n#'
          _UpperCAmelCase  :  Tuple				       ='\nif len_a > len_b:      result = a\nelse:      result = b'

          _UpperCAmelCase  :  Optional[int]				       =tokenizer.encode(snake_case)
          _UpperCAmelCase  :  List[str]				       =['^#', re.escape('<|endoftext|>'), '^\'\'\'', '^"""', '\n\n\n']
          _UpperCAmelCase  :  Dict				       =tokenizer.decode(snake_case    ,				truncate_before_pattern=snake_case)
          self.assertEqual(snake_case    ,				snake_case)






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




          '''simple docstring'''
          pass

