




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










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




