


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						(	SCREAMING_SNAKE_CASE,      unittest.TestCase  ):
       _UpperCamelCase     		=   ElectraTokenizer
       _UpperCamelCase     		=   ElectraTokenizerFast
       _UpperCamelCase     		=   True
       _UpperCamelCase     		=   True
       _UpperCamelCase     		=   filter_non_english

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        super().setUp()

        snake_case :			str							=   [
            '''[UNK]''',
            '''[CLS]''',
            '''[SEP]''',
            '''[PAD]''',
            '''[MASK]''',
            '''want''',
            '''##want''',
            '''##ed''',
            '''wa''',
            '''un''',
            '''runn''',
            '''##ing''',
            ''',''',
            '''low''',
            '''lowest''',
        ]
        snake_case :			Tuple							=   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 					UpperCAmelCase					(      self						,    a__       ):






        '''simple docstring'''






        snake_case :			str							=   '''UNwant\u00E9d,running'''
        snake_case :			Dict							=   '''unwanted, running'''
        return input_text, output_text

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Optional[int]							=   self.tokenizer_class(self.vocab_file       )

        snake_case :			Tuple							=   tokenizer.tokenize('''UNwant\u00E9d,running'''       )
        self.assertListEqual(a__						,    ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']       )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(a__       )						,    [9, 6, 7, 12, 10, 11]       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        if not self.test_rust_tokenizer:
         return

        snake_case :			Any							=   self.get_tokenizer()
        snake_case :			Optional[Any]							=   self.get_rust_tokenizer()

        snake_case :			str							=   '''UNwant\u00E9d,running'''

        snake_case :			Any							=   tokenizer.tokenize(a__       )
        snake_case :			List[Any]							=   rust_tokenizer.tokenize(a__       )
        self.assertListEqual(a__						,    a__       )

        snake_case :			List[Any]							=   tokenizer.encode(a__						,    add_special_tokens=a__       )
        snake_case :			Optional[Any]							=   rust_tokenizer.encode(a__						,    add_special_tokens=a__       )
        self.assertListEqual(a__						,    a__       )

        snake_case :			int							=   self.get_rust_tokenizer()
        snake_case :			str							=   tokenizer.encode(a__       )
        snake_case :			Dict							=   rust_tokenizer.encode(a__       )
        self.assertListEqual(a__						,    a__       )

        # With lower casing
        snake_case :			List[str]							=   self.get_tokenizer(do_lower_case=a__       )
        snake_case :			Any							=   self.get_rust_tokenizer(do_lower_case=a__       )

        snake_case :			Dict							=   '''UNwant\u00E9d,running'''

        snake_case :			List[Any]							=   tokenizer.tokenize(a__       )
        snake_case :			List[Any]							=   rust_tokenizer.tokenize(a__       )
        self.assertListEqual(a__						,    a__       )

        snake_case :			List[str]							=   tokenizer.encode(a__						,    add_special_tokens=a__       )
        snake_case :			int							=   rust_tokenizer.encode(a__						,    add_special_tokens=a__       )
        self.assertListEqual(a__						,    a__       )

        snake_case :			Tuple							=   self.get_rust_tokenizer()
        snake_case :			Optional[int]							=   tokenizer.encode(a__       )
        snake_case :			Optional[Any]							=   rust_tokenizer.encode(a__       )
        self.assertListEqual(a__						,    a__       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			int							=   BasicTokenizer()

        self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''       )						,    ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			List[Any]							=   BasicTokenizer(do_lower_case=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       )						,    ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )						,    ['''hello''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			str							=   BasicTokenizer(do_lower_case=a__						,    strip_accents=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )						,    ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )						,    ['''h\u00E9llo''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Optional[Any]							=   BasicTokenizer(do_lower_case=a__						,    strip_accents=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )						,    ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )						,    ['''hello''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			List[str]							=   BasicTokenizer(do_lower_case=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )						,    ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )						,    ['''hello''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			List[str]							=   BasicTokenizer(do_lower_case=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       )						,    ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Optional[int]							=   BasicTokenizer(do_lower_case=a__						,    strip_accents=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )						,    ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Dict							=   BasicTokenizer(do_lower_case=a__						,    strip_accents=a__       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )						,    ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			str							=   BasicTokenizer(do_lower_case=a__						,    never_split=['''[UNK]''']       )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''       )						,    ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']       )

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Any							=   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

        snake_case :			List[str]							=   {}
        for i, token in enumerate(a__       ):
         snake_case :			int							=   i
        snake_case :			Dict							=   WordpieceTokenizer(vocab=a__						,    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 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        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 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        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 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        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 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			int							=   self.get_tokenizer()
        snake_case :			Any							=   self.get_rust_tokenizer()

        # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
        self.assertListEqual([tokenizer.tokenize(a__       ) for t in ['''Test''', '''\xad''', '''test''']]						,    [['''[UNK]'''], [], ['''[UNK]''']]       )

        self.assertListEqual(
            [rust_tokenizer.tokenize(a__       ) for t in ['''Test''', '''\xad''', '''test''']]						,    [['''[UNK]'''], [], ['''[UNK]''']]       )

       @slow
       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Optional[Any]							=   self.tokenizer_class.from_pretrained('''google/electra-base-discriminator'''       )

        snake_case :			Optional[int]							=   tokenizer.encode('''sequence builders'''						,    add_special_tokens=a__       )
        snake_case :			int							=   tokenizer.encode('''multi-sequence build'''						,    add_special_tokens=a__       )

        snake_case :			List[str]							=   tokenizer.build_inputs_with_special_tokens(a__       )
        snake_case :			Tuple							=   tokenizer.build_inputs_with_special_tokens(a__						,    a__       )

        assert encoded_sentence == [1_01] + text + [1_02]
        assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






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

          snake_case :			Optional[int]							=   f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
          snake_case :			Optional[int]							=   tokenizer_r.encode_plus(
              a__						,    return_attention_mask=a__						,    return_token_type_ids=a__						,    return_offsets_mapping=a__						,    add_special_tokens=a__						,    )

          snake_case :			Dict							=   tokenizer_r.do_lower_case if hasattr(a__						,    '''do_lower_case'''       ) else False
          snake_case :			List[str]							=   (
              [
                  ((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 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Union[str, Any]							=   ['''的''', '''人''', '''有''']
        snake_case :			Any							=   ''''''.join(a__       )
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
          snake_case :			List[str]							=   True
          snake_case :			List[Any]							=   self.tokenizer_class.from_pretrained(a__						,    **a__       )
          snake_case :			List[Any]							=   self.rust_tokenizer_class.from_pretrained(a__						,    **a__       )

          snake_case :			List[Any]							=   tokenizer_p.encode(a__						,    add_special_tokens=a__       )
          snake_case :			Tuple							=   tokenizer_r.encode(a__						,    add_special_tokens=a__       )

          snake_case :			int							=   tokenizer_r.convert_ids_to_tokens(a__       )
          snake_case :			Any							=   tokenizer_p.convert_ids_to_tokens(a__       )

          # it is expected that each Chinese character is not preceded by "##"
          self.assertListEqual(a__						,    a__       )
          self.assertListEqual(a__						,    a__       )

          snake_case :			List[Any]							=   False
          snake_case :			Tuple							=   self.rust_tokenizer_class.from_pretrained(a__						,    **a__       )
          snake_case :			Dict							=   self.tokenizer_class.from_pretrained(a__						,    **a__       )

          snake_case :			int							=   tokenizer_r.encode(a__						,    add_special_tokens=a__       )
          snake_case :			Optional[int]							=   tokenizer_p.encode(a__						,    add_special_tokens=a__       )

          snake_case :			int							=   tokenizer_r.convert_ids_to_tokens(a__       )
          snake_case :			Dict							=   tokenizer_p.convert_ids_to_tokens(a__       )

          # it is expected that only the first Chinese character is not preceded by "##".
          snake_case :			Optional[int]							=   [
              f'''##{token}''' if idx != 0 else token for idx, token in enumerate(a__       )
          ]
          self.assertListEqual(a__						,    a__       )
          self.assertListEqual(a__						,    a__       )










import os






def  _UpperCAmelCase						( )		->Tuple:


 '''simple docstring'''
 snake_case :			Dict							=   0
 snake_case :			int							=   0
 with open(os.path.dirname(__lowerCamelCase							) + '''/p022_names.txt'''							) as file:
  snake_case :			int							=   str(file.readlines()[0]							)
  snake_case :			Any							=   name.replace('''"'''			,  ''''''							).split(''','''							)

 name.sort()
 for i in range(len(__lowerCamelCase							)							):
  for j in name[i]:
   temp_sum += ord(__lowerCamelCase							) - ord('''A'''							) + 1
  total_sum += (i + 1) * temp_sum
  snake_case :			List[Any]							=   0
 return total_sum


if __name__ == "__main__":
  print(solution())






