





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  _a  (					lowercase__       ,				unittest.TestCase				):






							"""simple docstring"""

							snake_case_							=    ElectraTokenizer
							snake_case_							=    ElectraTokenizerFast
							snake_case_							=    True
							snake_case_							=    True
							snake_case_							=    filter_non_english

							def   A_	(   self					:  Any     )						->int:
													super().setUp()

													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       [
													    "[UNK]",
													    "[CLS]",
													    "[SEP]",
													    "[PAD]",
													    "[MASK]",
													    "want",
													    "##want",
													    "##ed",
													    "wa",
													    "un",
													    "runn",
													    "##ing",
													    ",",
													    "low",
													    "lowest",
													]
													SCREAMING_SNAKE_CASE__  :					str =       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					:  str				,						a					:  Any     )						->Dict:
													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       "UNwant\u00E9d,running"
													SCREAMING_SNAKE_CASE__  :					str =       "unwanted, running"
													return input_text, output_text

							def   A_	(   self					:  int     )						->Tuple:
													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       self.tokenizer_class(self.vocab_file     )

													SCREAMING_SNAKE_CASE__  :					Any =       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   A_	(   self					:  List[Any]     )						->List[str]:
													if not self.test_rust_tokenizer:
																			return

													SCREAMING_SNAKE_CASE__  :					Dict =       self.get_tokenizer()
													SCREAMING_SNAKE_CASE__  :					List[Any] =       self.get_rust_tokenizer()

													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       "UNwant\u00E9d,running"

													SCREAMING_SNAKE_CASE__  :					Dict =       tokenizer.tokenize(a     )
													SCREAMING_SNAKE_CASE__  :					Tuple =       rust_tokenizer.tokenize(a     )
													self.assertListEqual(a				,						a     )

													SCREAMING_SNAKE_CASE__  :					List[Any] =       tokenizer.encode(a				,						add_special_tokens=a     )
													SCREAMING_SNAKE_CASE__  :					List[Any] =       rust_tokenizer.encode(a				,						add_special_tokens=a     )
													self.assertListEqual(a				,						a     )

													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       self.get_rust_tokenizer()
													SCREAMING_SNAKE_CASE__  :					Dict =       tokenizer.encode(a     )
													SCREAMING_SNAKE_CASE__  :					List[str] =       rust_tokenizer.encode(a     )
													self.assertListEqual(a				,						a     )

													# With lower casing
													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       self.get_tokenizer(do_lower_case=a     )
													SCREAMING_SNAKE_CASE__  :					List[Any] =       self.get_rust_tokenizer(do_lower_case=a     )

													SCREAMING_SNAKE_CASE__  :					Any =       "UNwant\u00E9d,running"

													SCREAMING_SNAKE_CASE__  :					List[Any] =       tokenizer.tokenize(a     )
													SCREAMING_SNAKE_CASE__  :					Tuple =       rust_tokenizer.tokenize(a     )
													self.assertListEqual(a				,						a     )

													SCREAMING_SNAKE_CASE__  :					Tuple =       tokenizer.encode(a				,						add_special_tokens=a     )
													SCREAMING_SNAKE_CASE__  :					Dict =       rust_tokenizer.encode(a				,						add_special_tokens=a     )
													self.assertListEqual(a				,						a     )

													SCREAMING_SNAKE_CASE__  :					str =       self.get_rust_tokenizer()
													SCREAMING_SNAKE_CASE__  :					List[Any] =       tokenizer.encode(a     )
													SCREAMING_SNAKE_CASE__  :					Optional[Any] =       rust_tokenizer.encode(a     )
													self.assertListEqual(a				,						a     )

							def   A_	(   self					:  List[Any]     )						->Optional[Any]:
													SCREAMING_SNAKE_CASE__  :					Any =       BasicTokenizer()

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

							def   A_	(   self					:  Tuple     )						->Dict:
													SCREAMING_SNAKE_CASE__  :					List[str] =       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   A_	(   self					:  Any     )						->Tuple:
													SCREAMING_SNAKE_CASE__  :					int =       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   A_	(   self					:  Tuple     )						->int:
													SCREAMING_SNAKE_CASE__  :					Union[str, 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   A_	(   self					:  Any     )						->Union[str, Any]:
													SCREAMING_SNAKE_CASE__  :					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   A_	(   self					:  List[Any]     )						->str:
													SCREAMING_SNAKE_CASE__  :					int =       BasicTokenizer(do_lower_case=a     )

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

							def   A_	(   self					:  Any     )						->List[str]:
													SCREAMING_SNAKE_CASE__  :					Tuple =       BasicTokenizer(do_lower_case=a				,						strip_accents=a     )

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

							def   A_	(   self					:  List[Any]     )						->List[Any]:
													SCREAMING_SNAKE_CASE__  :					Tuple =       BasicTokenizer(do_lower_case=a				,						strip_accents=a     )

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

							def   A_	(   self					:  List[str]     )						->Union[str, Any]:
													SCREAMING_SNAKE_CASE__  :					Tuple =       BasicTokenizer(do_lower_case=a				,						never_split=["[UNK]"]     )

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

							def   A_	(   self					:  Tuple     )						->Any:
													SCREAMING_SNAKE_CASE__  :					Tuple =       ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

													SCREAMING_SNAKE_CASE__  :					int =       {}
													for i, token in enumerate(a     ):
																			SCREAMING_SNAKE_CASE__  :					Any =       i
													SCREAMING_SNAKE_CASE__  :					Tuple =       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   A_	(   self					:  List[Any]     )						->int:
													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[Any]     )						->int:
													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					:  Optional[int]     )						->Dict:
													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					:  List[str]     )						->Union[str, Any]:
													SCREAMING_SNAKE_CASE__  :					Dict =       self.get_tokenizer()
													SCREAMING_SNAKE_CASE__  :					Optional[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   A_	(   self					:  str     )						->int:
													SCREAMING_SNAKE_CASE__  :					List[Any] =       self.tokenizer_class.from_pretrained("google/electra-base-discriminator"     )

													SCREAMING_SNAKE_CASE__  :					List[str] =       tokenizer.encode("sequence builders"				,						add_special_tokens=a     )
													SCREAMING_SNAKE_CASE__  :					Optional[Any] =       tokenizer.encode("multi-sequence build"				,						add_special_tokens=a     )

													SCREAMING_SNAKE_CASE__  :					List[str] =       tokenizer.build_inputs_with_special_tokens(a     )
													SCREAMING_SNAKE_CASE__  :					Any =       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   A_	(   self					:  str     )						->Union[str, Any]:
													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""     ):
																									SCREAMING_SNAKE_CASE__  :					Dict =       self.rust_tokenizer_class.from_pretrained(a				,						**a     )

																									SCREAMING_SNAKE_CASE__  :					Optional[int] =       f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
																									SCREAMING_SNAKE_CASE__  :					Any =       tokenizer_r.encode_plus(
																									    a				,						return_attention_mask=a				,						return_token_type_ids=a				,						return_offsets_mapping=a				,						add_special_tokens=a				,						)

																									SCREAMING_SNAKE_CASE__  :					Any =       tokenizer_r.do_lower_case if hasattr(a				,						"do_lower_case"     ) else False
																									SCREAMING_SNAKE_CASE__  :					List[Any] =       (
																									    [
																									        ((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					:  List[Any]     )						->Tuple:
													SCREAMING_SNAKE_CASE__  :					Dict =       ["的", "人", "有"]
													SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       "".join(a     )
													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""     ):
																									SCREAMING_SNAKE_CASE__  :					List[str] =       True
																									SCREAMING_SNAKE_CASE__  :					Any =       self.tokenizer_class.from_pretrained(a				,						**a     )
																									SCREAMING_SNAKE_CASE__  :					str =       self.rust_tokenizer_class.from_pretrained(a				,						**a     )

																									SCREAMING_SNAKE_CASE__  :					List[Any] =       tokenizer_p.encode(a				,						add_special_tokens=a     )
																									SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       tokenizer_r.encode(a				,						add_special_tokens=a     )

																									SCREAMING_SNAKE_CASE__  :					Tuple =       tokenizer_r.convert_ids_to_tokens(a     )
																									SCREAMING_SNAKE_CASE__  :					List[str] =       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     )

																									SCREAMING_SNAKE_CASE__  :					int =       False
																									SCREAMING_SNAKE_CASE__  :					Any =       self.rust_tokenizer_class.from_pretrained(a				,						**a     )
																									SCREAMING_SNAKE_CASE__  :					Union[str, Any] =       self.tokenizer_class.from_pretrained(a				,						**a     )

																									SCREAMING_SNAKE_CASE__  :					int =       tokenizer_r.encode(a				,						add_special_tokens=a     )
																									SCREAMING_SNAKE_CASE__  :					List[str] =       tokenizer_p.encode(a				,						add_special_tokens=a     )

																									SCREAMING_SNAKE_CASE__  :					List[str] =       tokenizer_r.convert_ids_to_tokens(a     )
																									SCREAMING_SNAKE_CASE__  :					Dict =       tokenizer_p.convert_ids_to_tokens(a     )

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






from itertools import combinations_with_replacement







def    UpperCAmelCase				(  _lowerCamelCase   :	int = 100  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					list[int] =       [*list(range(1      , 21  )  ), 25]
						SCREAMING_SNAKE_CASE__  :					list[int] =       [2 * x for x in range(1      , 21  )] + [50]
						SCREAMING_SNAKE_CASE__  :					list[int] =       [3 * x for x in range(1      , 21  )]
						SCREAMING_SNAKE_CASE__  :					list[int] =       singles + doubles + triples + [0]

						SCREAMING_SNAKE_CASE__  :					int =       0
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int
						SCREAMING_SNAKE_CASE__  :					int

						for double in doubles:
												for throwa, throwa in combinations_with_replacement(_lowerCamelCase      , 2  ):
																		SCREAMING_SNAKE_CASE__  :					int =       double + throwa + throwa
																		if checkout_total < limit:
																								num_checkouts += 1

						return num_checkouts


if __name__ == "__main__":
				print(f"{solution() = }")