


import json
import os
import subprocess
import sys
import warnings
from argparse import ArgumentParser
from contextlib import AbstractContextManager
from typing import Dict, List, Optional

import requests

from ..utils import logging
from . import BaseTransformersCLICommand


UpperCamelCase			:					Tuple         =							logging.get_logger(__name__)  # pylint: disable=invalid-name


UpperCamelCase			:					str         =							'''lfs-multipart-upload'''

class      __snake_case				(   _UpperCAmelCase):
					@staticmethod
					def 	a			(						_lowerCAmelCase       :						ArgumentParser  )							->					int:



											'''simple docstring'''





											__magic_name__					=      parser.add_parser(
											    'lfs-enable-largefiles'	,      help=(
											        'Deprecated: use `huggingface-cli` instead. Configure your repository to enable upload of files > 5GB.'
											    )	,      )
											enable_parser.add_argument('path'	,      type=_lowerCAmelCase	,      help='Local path to repository you want to configure.'  )
											enable_parser.set_defaults(func=lambda _lowerCAmelCase  : LfsEnableCommand(_lowerCAmelCase  )  )

											__magic_name__					=      parser.add_parser(
											    _lowerCAmelCase	,      help=(
											        'Deprecated: use `huggingface-cli` instead. '
											        'Command will get called by git-lfs, do not call it directly.'
											    )	,      )
											upload_parser.set_defaults(func=lambda _lowerCAmelCase  : LfsUploadCommand(_lowerCAmelCase  )  )







class      __snake_case				:
					def __init__(						self       :						str	,      _lowerCAmelCase       :						List[str]  )							->					str:



											'''simple docstring'''





											__magic_name__					=      args







					def 	a			(						self       :						str  )							->					int:



											'''simple docstring'''





											warnings.warn(
											    'Managing repositories through transformers-cli is deprecated. Please use `huggingface-cli` instead.'  )
											__magic_name__					=      os.path.abspath(self.args.path  )
											if not os.path.isdir(_lowerCAmelCase  ):
																	print('This does not look like a valid git repo.'  )
																	exit(1  )
											subprocess.run(
											    'git config lfs.customtransfer.multipart.path transformers-cli'.split()	,      check=_lowerCAmelCase	,      cwd=_lowerCAmelCase  )
											subprocess.run(
											    F'''git config lfs.customtransfer.multipart.args {LFS_MULTIPART_UPLOAD_COMMAND}'''.split()	,      check=_lowerCAmelCase	,      cwd=_lowerCAmelCase	,      )
											print('Local repo set up for largefiles'  )







def 				UpperCamelCase_	(					__snake_case      :    Dict  )->   Dict:




						'''simple docstring'''
						__magic_name__					=      json.dumps(__snake_case  ) + '\n'
						sys.stdout.write(__snake_case  )
						sys.stdout.flush()
def 				UpperCamelCase_	(					)->   Optional[Dict]:




						'''simple docstring'''
						__magic_name__					=      json.loads(sys.stdin.readline().strip()  )

						if "terminate" in (msg.get('type'  ), msg.get('event'  )):
												# terminate message received
												return None

						if msg.get('event'  ) not in ("download", "upload"):
												logger.critical('Received unexpected message'  )
												sys.exit(1  )

						return msg

class      __snake_case				(   _UpperCAmelCase):
					def __init__(						self       :						Optional[int]	,      _lowerCAmelCase       :						str	,      _lowerCAmelCase       :						int	,      _lowerCAmelCase       :						int  )							->					str:



											'''simple docstring'''





											__magic_name__					=      filepath
											__magic_name__					=      seek_from
											__magic_name__					=      read_limit
											__magic_name__					=      0
					def __enter__(						self       :						Optional[Any]  )							->					int:



											'''simple docstring'''





											__magic_name__					=      open(self.filepath	,      'rb'  )
											self.f.seek(self.seek_from  )
											return self
					def __len__(						self       :						Dict  )							->					int:



											'''simple docstring'''





											__magic_name__					=      os.fstat(self.f.fileno()  ).st_size
											return min(self.read_limit	,      total_length - self.seek_from  )
					def 	a			(						self       :						Optional[Any]	,      _lowerCAmelCase       :						Tuple=-1  )							->					Optional[int]:



											'''simple docstring'''





											if self.n_seen >= self.read_limit:
																	return b""
											__magic_name__					=      self.read_limit - self.n_seen
											__magic_name__					=      self.f.read(remaining_amount if n < 0 else min(_lowerCAmelCase	,      _lowerCAmelCase  )  )
											self.n_seen += len(_lowerCAmelCase  )
											return data
					def __iter__(						self       :						Tuple  )							->					List[Any]:



											'''simple docstring'''





											yield self.read(n=4 * 1_0_2_4 * 1_0_2_4  )







					def __exit__(						self       :						Tuple	,      *_lowerCAmelCase       :						Union[str, Any]  )							->					List[Any]:



											'''simple docstring'''





											self.f.close()







class      __snake_case				:
					def __init__(						self       :						str	,      _lowerCAmelCase       :						Optional[Any]  )							->					Optional[int]:



											'''simple docstring'''





											__magic_name__					=      args







					def 	a			(						self       :						List[str]  )							->					int:



											'''simple docstring'''





											__magic_name__					=      json.loads(sys.stdin.readline().strip()  )
											if not (init_msg.get('event'  ) == "init" and init_msg.get('operation'  ) == "upload"):
																	write_msg({'error': {'code': 3_2, 'message': 'Wrong lfs init operation'}}  )
																	sys.exit(1  )

											# The transfer process should use the information it needs from the
											# initiation structure, and also perform any one-off setup tasks it
											# needs to do. It should then respond on stdout with a simple empty
											# confirmation structure, as follows:
											write_msg({}  )

											# After the initiation exchange, git-lfs will send any number of
											# transfer requests to the stdin of the transfer process, in a serial sequence.
											while True:
																	__magic_name__					=      read_msg()
																	if msg is None:
																							# When all transfers have been processed, git-lfs will send
																							# a terminate event to the stdin of the transfer process.
																							# On receiving this message the transfer process should
																							# clean up and terminate. No response is expected.
																							sys.exit(0  )

																	__magic_name__					=      msg['oid']
																	__magic_name__					=      msg['path']
																	__magic_name__					=      msg['action']['href']
																	__magic_name__					=      msg['action']['header']
																	__magic_name__					=      int(header.pop('chunk_size'  )  )
																	__magic_name__					=      list(header.values()  )

																	__magic_name__					=      []
																	for i, presigned_url in enumerate(_lowerCAmelCase  ):
																							with FileSlice(_lowerCAmelCase	,      seek_from=i * chunk_size	,      read_limit=_lowerCAmelCase  ) as data:
																													__magic_name__					=      requests.put(_lowerCAmelCase	,      data=_lowerCAmelCase  )
																													r.raise_for_status()
																													parts.append(
																													    {
																													        'etag': r.headers.get('etag'  ),
																													        'partNumber': i + 1,
																													    }  )
																													# In order to support progress reporting while data is uploading / downloading,
																													# the transfer process should post messages to stdout
																													write_msg(
																													    {
																													        'event': 'progress',
																													        'oid': oid,
																													        'bytesSoFar': (i + 1) * chunk_size,
																													        'bytesSinceLast': chunk_size,
																													    }  )
																													# Not precise but that's ok.

																	__magic_name__					=      requests.post(
																	    _lowerCAmelCase	,      json={
																	        'oid': oid,
																	        'parts': parts,
																	    }	,      )
																	r.raise_for_status()

																	write_msg({'event': 'complete', 'oid': oid}  )





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      __snake_case				(   _UpperCAmelCase	,      unittest.TestCase):
					SCREAMING_SNAKE_CASE_		:       str								=			ElectraTokenizer
					SCREAMING_SNAKE_CASE_		:       Any								=			ElectraTokenizerFast
					SCREAMING_SNAKE_CASE_		:       Tuple								=			True
					SCREAMING_SNAKE_CASE_		:       str								=			True
					SCREAMING_SNAKE_CASE_		:       str								=			filter_non_english
					def 	a			(						self       :						int  )							->					Optional[int]:



											'''simple docstring'''





											super().setUp()

											__magic_name__					=      [
											    '[UNK]',
											    '[CLS]',
											    '[SEP]',
											    '[PAD]',
											    '[MASK]',
											    'want',
											    '##want',
											    '##ed',
											    'wa',
											    'un',
											    'runn',
											    '##ing',
											    ',',
											    'low',
											    'lowest',
											]
											__magic_name__					=      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       :						Tuple	,      _lowerCAmelCase       :						Dict  )							->					List[Any]:



											'''simple docstring'''





											__magic_name__					=      'UNwant\u00E9d,running'
											__magic_name__					=      'unwanted, running'
											return input_text, output_text
					def 	a			(						self       :						Union[str, Any]  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      self.tokenizer_class(self.vocab_file  )

											__magic_name__					=      tokenizer.tokenize('UNwant\u00E9d,running'  )
											self.assertListEqual(_lowerCAmelCase	,      ['un', '##want', '##ed', ',', 'runn', '##ing']  )
											self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase  )	,      [9, 6, 7, 1_2, 1_0, 1_1]  )
					def 	a			(						self       :						Optional[int]  )							->					Dict:



											'''simple docstring'''





											if not self.test_rust_tokenizer:
																	return

											__magic_name__					=      self.get_tokenizer()
											__magic_name__					=      self.get_rust_tokenizer()

											__magic_name__					=      'UNwant\u00E9d,running'

											__magic_name__					=      tokenizer.tokenize(_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.tokenize(_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

											__magic_name__					=      tokenizer.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

											__magic_name__					=      self.get_rust_tokenizer()
											__magic_name__					=      tokenizer.encode(_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.encode(_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

											# With lower casing
											__magic_name__					=      self.get_tokenizer(do_lower_case=_lowerCAmelCase  )
											__magic_name__					=      self.get_rust_tokenizer(do_lower_case=_lowerCAmelCase  )

											__magic_name__					=      'UNwant\u00E9d,running'

											__magic_name__					=      tokenizer.tokenize(_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.tokenize(_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

											__magic_name__					=      tokenizer.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

											__magic_name__					=      self.get_rust_tokenizer()
											__magic_name__					=      tokenizer.encode(_lowerCAmelCase  )
											__magic_name__					=      rust_tokenizer.encode(_lowerCAmelCase  )
											self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )
					def 	a			(						self       :						str  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer()

											self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'  )	,      ['ah', '\u535A', '\u63A8', 'zz']  )
					def 	a			(						self       :						Optional[int]  )							->					int:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '  )	,      ['hello', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )	,      ['hello']  )
					def 	a			(						self       :						int  )							->					Union[str, Any]:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase	,      strip_accents=_lowerCAmelCase  )

											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       :						Any  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase	,      strip_accents=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )	,      ['hallo', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )	,      ['hello']  )
					def 	a			(						self       :						List[str]  )							->					str:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )	,      ['hallo', '!', 'how', 'are', 'you', '?']  )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )	,      ['hello']  )
					def 	a			(						self       :						Union[str, Any]  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '  )	,      ['HeLLo', '!', 'how', 'Are', 'yoU', '?']  )
					def 	a			(						self       :						int  )							->					int:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase	,      strip_accents=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )	,      ['HäLLo', '!', 'how', 'Are', 'yoU', '?']  )
					def 	a			(						self       :						Dict  )							->					int:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase	,      strip_accents=_lowerCAmelCase  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '  )	,      ['HaLLo', '!', 'how', 'Are', 'yoU', '?']  )
					def 	a			(						self       :						Tuple  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      BasicTokenizer(do_lower_case=_lowerCAmelCase	,      never_split=['[UNK]']  )

											self.assertListEqual(
											    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'  )	,      ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']  )
					def 	a			(						self       :						Dict  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

											__magic_name__					=      {}
											for i, token in enumerate(_lowerCAmelCase  ):
																	__magic_name__					=      i
											__magic_name__					=      WordpieceTokenizer(vocab=_lowerCAmelCase	,      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       :						List[str]  )							->					Union[str, Any]:



											'''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 	a			(						self       :						Optional[int]  )							->					Dict:



											'''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 	a			(						self       :						List[Any]  )							->					List[str]:



											'''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 	a			(						self       :						Optional[Any]  )							->					int:



											'''simple docstring'''





											__magic_name__					=      self.get_tokenizer()
											__magic_name__					=      self.get_rust_tokenizer()

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

											self.assertListEqual(
											    [rust_tokenizer.tokenize(_lowerCAmelCase  ) for t in ['Test', '\xad', 'test']]	,      [['[UNK]'], [], ['[UNK]']]  )
					@slow
					def 	a			(						self       :						str  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      self.tokenizer_class.from_pretrained('google/electra-base-discriminator'  )

											__magic_name__					=      tokenizer.encode('sequence builders'	,      add_special_tokens=_lowerCAmelCase  )
											__magic_name__					=      tokenizer.encode('multi-sequence build'	,      add_special_tokens=_lowerCAmelCase  )

											__magic_name__					=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase  )
											__magic_name__					=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase	,      _lowerCAmelCase  )

											assert encoded_sentence == [1_0_1] + text + [1_0_2]
											assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]
					def 	a			(						self       :						int  )							->					Union[str, Any]:



											'''simple docstring'''





											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																							__magic_name__					=      self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase	,      **_lowerCAmelCase  )

																							__magic_name__					=      F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																							__magic_name__					=      tokenizer_r.encode_plus(
																							    _lowerCAmelCase	,      return_attention_mask=_lowerCAmelCase	,      return_token_type_ids=_lowerCAmelCase	,      return_offsets_mapping=_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase	,      )

																							__magic_name__					=      tokenizer_r.do_lower_case if hasattr(_lowerCAmelCase	,      'do_lower_case'  ) else False
																							__magic_name__					=      (
																							    [
																							        ((0, 0), tokenizer_r.cls_token),
																							        ((0, 1), 'A'),
																							        ((1, 2), ','),
																							        ((3, 5), 'na'),
																							        ((5, 6), '##ï'),
																							        ((6, 8), '##ve'),
																							        ((9, 1_5), tokenizer_r.mask_token),
																							        ((1_6, 2_1), 'Allen'),
																							        ((2_1, 2_3), '##NL'),
																							        ((2_3, 2_4), '##P'),
																							        ((2_5, 3_3), 'sentence'),
																							        ((3_3, 3_4), '.'),
																							        ((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, 1_5), tokenizer_r.mask_token),
																							        ((1_6, 2_1), 'allen'),
																							        ((2_1, 2_3), '##nl'),
																							        ((2_3, 2_4), '##p'),
																							        ((2_5, 3_3), 'sentence'),
																							        ((3_3, 3_4), '.'),
																							        ((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       :						Any  )							->					int:



											'''simple docstring'''





											__magic_name__					=      ['的', '人', '有']
											__magic_name__					=      ''.join(_lowerCAmelCase  )
											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
																							__magic_name__					=      True
																							__magic_name__					=      self.tokenizer_class.from_pretrained(_lowerCAmelCase	,      **_lowerCAmelCase  )
																							__magic_name__					=      self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase	,      **_lowerCAmelCase  )

																							__magic_name__					=      tokenizer_p.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
																							__magic_name__					=      tokenizer_r.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )

																							__magic_name__					=      tokenizer_r.convert_ids_to_tokens(_lowerCAmelCase  )
																							__magic_name__					=      tokenizer_p.convert_ids_to_tokens(_lowerCAmelCase  )

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

																							__magic_name__					=      False
																							__magic_name__					=      self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase	,      **_lowerCAmelCase  )
																							__magic_name__					=      self.tokenizer_class.from_pretrained(_lowerCAmelCase	,      **_lowerCAmelCase  )

																							__magic_name__					=      tokenizer_r.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )
																							__magic_name__					=      tokenizer_p.encode(_lowerCAmelCase	,      add_special_tokens=_lowerCAmelCase  )

																							__magic_name__					=      tokenizer_r.convert_ids_to_tokens(_lowerCAmelCase  )
																							__magic_name__					=      tokenizer_p.convert_ids_to_tokens(_lowerCAmelCase  )

																							# it is expected that only the first Chinese character is not preceded by "##".
																							__magic_name__					=      [
																							    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(_lowerCAmelCase  )
																							]
																							self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )
																							self.assertListEqual(_lowerCAmelCase	,      _lowerCAmelCase  )

