code: 
  
  
  
  
  """simple docstring"""
  
  
  
  
  import os
  import unittest
  
  from transformers import ElectraTokenizerFast
  from transformers.models.electra.tokenization_electra import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      ElectraTokenizer,
      WordpieceTokenizer,
      _is_control,
      _is_punctuation,
      _is_whitespace,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
  @require_tokenizers
  class 							lowerCamelCase		( _UpperCAmelCase	,  unittest.TestCase				):
     lowercase       :  int      =				ElectraTokenizer
     lowercase       :  Tuple      =				ElectraTokenizerFast
     lowercase       :  Optional[Any]      =				True
     lowercase       :  Tuple      =				True
     lowercase       :  int      =				filter_non_english
  
  
  
  
  
  
  
     def       a_							(							self ):
         super().setUp()
  
         UpperCamelCase				:   Tuple          =							[
             """[UNK]""",
             """[CLS]""",
             """[SEP]""",
             """[PAD]""",
             """[MASK]""",
             """want""",
             """##want""",
             """##ed""",
             """wa""",
             """un""",
             """runn""",
             """##ing""",
             """,""",
             """low""",
             """lowest""",
         ]
         UpperCamelCase				:   int          =							os.path.join(self.tmpdirname    ,      VOCAB_FILES_NAMES["""vocab_file"""] )
         with open(self.vocab_file    ,      """w"""    ,      encoding="""utf-8""" ) as vocab_writer:
             vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) )
  
  
  
  
  
  
  
     def       a_							(							self    ,      SCREAMING_SNAKE_CASE_ ):
         UpperCamelCase				:   Union[str, Any]          =							"""UNwant\u00E9d,running"""
         UpperCamelCase				:   Union[str, Any]          =							"""unwanted, running"""
         return input_text, output_text
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Optional[int]          =							self.tokenizer_class(self.vocab_file )
  
         UpperCamelCase				:   str          =							tokenizer.tokenize("""UNwant\u00E9d,running""" )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] )
         self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_ )    ,      [9, 6, 7, 12, 10, 11] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         if not self.test_rust_tokenizer:
             return
  
         UpperCamelCase				:   Union[str, Any]          =							self.get_tokenizer()
         UpperCamelCase				:   Any          =							self.get_rust_tokenizer()
  
         UpperCamelCase				:   Optional[Any]          =							"""UNwant\u00E9d,running"""
  
         UpperCamelCase				:   Tuple          =							tokenizer.tokenize(SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   Optional[Any]          =							rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   str          =							tokenizer.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   str          =							rust_tokenizer.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   Tuple          =							self.get_rust_tokenizer()
         UpperCamelCase				:   Any          =							tokenizer.encode(SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   Optional[int]          =							rust_tokenizer.encode(SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         # With lower casing
         UpperCamelCase				:   str          =							self.get_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   str          =							self.get_rust_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   Optional[Any]          =							"""UNwant\u00E9d,running"""
  
         UpperCamelCase				:   Optional[int]          =							tokenizer.tokenize(SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   Optional[int]          =							rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   Dict          =							tokenizer.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   int          =							rust_tokenizer.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   Any          =							self.get_rust_tokenizer()
         UpperCamelCase				:   List[Any]          =							tokenizer.encode(SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   Any          =							rust_tokenizer.encode(SCREAMING_SNAKE_CASE_ )
         self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   str          =							BasicTokenizer()
  
         self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" )    ,      ["""ah""", """\u535A""", """\u63A8""", """zz"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   int          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """ )    ,      ["""hello""", """!""", """how""", """are""", """you""", """?"""] )
         self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )    ,      ["""hello"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Union[str, Any]          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    ,      strip_accents=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )    ,      ["""hällo""", """!""", """how""", """are""", """you""", """?"""] )
         self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )    ,      ["""h\u00E9llo"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Dict          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    ,      strip_accents=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )    ,      ["""hallo""", """!""", """how""", """are""", """you""", """?"""] )
         self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )    ,      ["""hello"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Any          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )    ,      ["""hallo""", """!""", """how""", """are""", """you""", """?"""] )
         self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" )    ,      ["""hello"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Tuple          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """ )    ,      ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   int          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    ,      strip_accents=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )    ,      ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Tuple          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    ,      strip_accents=SCREAMING_SNAKE_CASE_ )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """ )    ,      ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Tuple          =							BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    ,      never_split=["""[UNK]"""] )
  
         self.assertListEqual(
             tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]""" )    ,      ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   Tuple          =							["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]
  
         UpperCamelCase				:   str          =							{}
         for i, token in enumerate(SCREAMING_SNAKE_CASE_ ):
             UpperCamelCase				:   Any          =							i
         UpperCamelCase				:   Dict          =							WordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_    ,      unk_token="""[UNK]""" )
  
         self.assertListEqual(tokenizer.tokenize("""""" )    ,      [] )
  
         self.assertListEqual(tokenizer.tokenize("""unwanted running""" )    ,      ["""un""", """##want""", """##ed""", """runn""", """##ing"""] )
  
         self.assertListEqual(tokenizer.tokenize("""unwantedX running""" )    ,      ["""[UNK]""", """runn""", """##ing"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         self.assertTrue(_is_whitespace(""" """ ) )
         self.assertTrue(_is_whitespace("""\t""" ) )
         self.assertTrue(_is_whitespace("""\r""" ) )
         self.assertTrue(_is_whitespace("""\n""" ) )
         self.assertTrue(_is_whitespace("""\u00A0""" ) )
  
         self.assertFalse(_is_whitespace("""A""" ) )
         self.assertFalse(_is_whitespace("""-""" ) )
  
  
  
  
  
  
  
     def       a_							(							self ):
         self.assertTrue(_is_control("""\u0005""" ) )
  
         self.assertFalse(_is_control("""A""" ) )
         self.assertFalse(_is_control(""" """ ) )
         self.assertFalse(_is_control("""\t""" ) )
         self.assertFalse(_is_control("""\r""" ) )
  
  
  
  
  
  
  
     def       a_							(							self ):
         self.assertTrue(_is_punctuation("""-""" ) )
         self.assertTrue(_is_punctuation("""$""" ) )
         self.assertTrue(_is_punctuation("""`""" ) )
         self.assertTrue(_is_punctuation(""".""" ) )
  
         self.assertFalse(_is_punctuation("""A""" ) )
         self.assertFalse(_is_punctuation(""" """ ) )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   List[str]          =							self.get_tokenizer()
         UpperCamelCase				:   Any          =							self.get_rust_tokenizer()
  
         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE_ ) for t in ["""Test""", """\xad""", """test"""]]    ,      [["""[UNK]"""], [], ["""[UNK]"""]] )
  
         self.assertListEqual(
             [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_ ) for t in ["""Test""", """\xad""", """test"""]]    ,      [["""[UNK]"""], [], ["""[UNK]"""]] )
  
  
  
  
  
  
  
     @slow
     def       a_							(							self ):
         UpperCamelCase				:   List[Any]          =							self.tokenizer_class.from_pretrained("""google/electra-base-discriminator""" )
  
         UpperCamelCase				:   Any          =							tokenizer.encode("""sequence builders"""    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   Dict          =							tokenizer.encode("""multi-sequence build"""    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
  
         UpperCamelCase				:   List[str]          =							tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_ )
         UpperCamelCase				:   List[str]          =							tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
         assert encoded_sentence == [101] + text + [102]
         assert encoded_pair == [101] + text + [102] + text_a + [102]
  
  
  
  
  
  
  
     def       a_							(							self ):
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ):
                 UpperCamelCase				:   Union[str, Any]          =							self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   List[Any]          =							f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
                 UpperCamelCase				:   Tuple          =							tokenizer_r.encode_plus(
                     SCREAMING_SNAKE_CASE_    ,      return_attention_mask=SCREAMING_SNAKE_CASE_    ,      return_token_type_ids=SCREAMING_SNAKE_CASE_    ,      return_offsets_mapping=SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_    ,      )
  
                 UpperCamelCase				:   List[Any]          =							tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE_    ,      """do_lower_case""" ) else False
                 UpperCamelCase				:   Optional[int]          =							(
                     [
                         ((0, 0), tokenizer_r.cls_token),
                         ((0, 1), """A"""),
                         ((1, 2), ""","""),
                         ((3, 5), """na"""),
                         ((5, 6), """##ï"""),
                         ((6, 8), """##ve"""),
                         ((9, 15), tokenizer_r.mask_token),
                         ((16, 21), """Allen"""),
                         ((21, 23), """##NL"""),
                         ((23, 24), """##P"""),
                         ((25, 33), """sentence"""),
                         ((33, 34), """."""),
                         ((0, 0), tokenizer_r.sep_token),
                     ]
                     if not do_lower_case
                     else [
                         ((0, 0), tokenizer_r.cls_token),
                         ((0, 1), """a"""),
                         ((1, 2), ""","""),
                         ((3, 8), """naive"""),
                         ((9, 15), tokenizer_r.mask_token),
                         ((16, 21), """allen"""),
                         ((21, 23), """##nl"""),
                         ((23, 24), """##p"""),
                         ((25, 33), """sentence"""),
                         ((33, 34), """."""),
                         ((0, 0), tokenizer_r.sep_token),
                     ]
                 )
  
                 self.assertEqual(
                     [e[1] for e in expected_results]    ,      tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""] ) )
                 self.assertEqual([e[0] for e in expected_results]    ,      tokens["""offset_mapping"""] )
  
  
  
  
  
  
  
     def       a_							(							self ):
         UpperCamelCase				:   int          =							["""的""", """人""", """有"""]
         UpperCamelCase				:   List[Any]          =							"""""".join(SCREAMING_SNAKE_CASE_ )
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ):
                 UpperCamelCase				:   Union[str, Any]          =							True
                 UpperCamelCase				:   Dict          =							self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   str          =							self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   Tuple          =							tokenizer_p.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   Union[str, Any]          =							tokenizer_r.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   Union[str, Any]          =							tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   Any          =							tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_ )
  
                 # it is expected that each Chinese character is not preceded by "##"
                 self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
                 self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   Any          =							False
                 UpperCamelCase				:   Union[str, Any]          =							self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   Optional[int]          =							self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,      **SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   List[str]          =							tokenizer_r.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   Dict          =							tokenizer_p.encode(SCREAMING_SNAKE_CASE_    ,      add_special_tokens=SCREAMING_SNAKE_CASE_ )
  
                 UpperCamelCase				:   List[Any]          =							tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_ )
                 UpperCamelCase				:   int          =							tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_ )
  
                 # it is expected that only the first Chinese character is not preceded by "##".
                 UpperCamelCase				:   List[Any]          =							[
                     f'##{token}' if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE_ )
                 ]
                 self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
                 self.assertListEqual(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_ )
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  
  class 							lowerCamelCase		:
  
  
  
  
  
  
  
     def __init__(							self    ,      SCREAMING_SNAKE_CASE_=None ):
         UpperCamelCase				:   Optional[Any]          =							data
         UpperCamelCase				:   str          =							None
  
  
  
  
  
  
  
     def __repr__(							self ):
         UpperCamelCase				:   str          =							""""""
         UpperCamelCase				:   Any          =							self
         while temp:
             string_rep += f'<{temp.data}> ---> '
             UpperCamelCase				:   Optional[int]          =							temp.next
         string_rep += "<END>"
         return string_rep
  
  
  
  
  
  
  
  def 					A_			(		snake_case_     :       Tuple    ):
  
  
  
  
  
  
  
      '''simple docstring'''
  
      # if elements_list is empty
      if not elements_list:
          raise Exception("""The Elements List is empty"""    )
  
      # Set first element as Head
      UpperCamelCase				:   List[Any]          =							Node(elements_list[0]    )
      UpperCamelCase				:   str          =							head
      # Loop through elements from position 1
      for data in elements_list[1:]:
          UpperCamelCase				:   Optional[int]          =							Node(snake_case_    )
          UpperCamelCase				:   Optional[Any]          =							current.next
      return head
  
  
  __A :		List[Any]      							=    [1, 3, 5, 32, 44, 12, 43]
  print(F'''List: {list_data}''')
  print('''Creating Linked List from List.''')
  __A :		int      							=    make_linked_list(list_data)
  print('''Linked List:''')
  
  
  print(linked_list)
  
  
  
  
  