
"""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__   (   __magic_name__					,      unittest.TestCase							):





			'''simple docstring'''
			lowerCamelCase       =						ElectraTokenizer
			lowerCamelCase       =						ElectraTokenizerFast
			lowerCamelCase       =						True
			lowerCamelCase       =						True
			lowerCamelCase       =						filter_non_english



			def    _lowerCAmelCase						(				self    )					->	str:
				super().setUp()

				_lowerCAmelCase								=[
				    """[UNK]""",
				    """[CLS]""",
				    """[SEP]""",
				    """[PAD]""",
				    """[MASK]""",
				    """want""",
				    """##want""",
				    """##ed""",
				    """wa""",
				    """un""",
				    """runn""",
				    """##ing""",
				    """,""",
				    """low""",
				    """lowest""",
				]
				_lowerCAmelCase								=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    _lowerCAmelCase						(				self	,	__UpperCAmelCase    )					->	Optional[Any]:
				_lowerCAmelCase								="""UNwant\u00E9d,running"""
				_lowerCAmelCase								="""unwanted, running"""
				return input_text, output_text



			def    _lowerCAmelCase						(				self    )					->	Optional[int]:
				_lowerCAmelCase								=self.tokenizer_class(self.vocab_file    )

				_lowerCAmelCase								=tokenizer.tokenize("""UNwant\u00E9d,running"""    )
				self.assertListEqual(__UpperCAmelCase	,	["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]    )
				self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCAmelCase    )	,	[9, 6, 7, 12, 10, 11]    )



			def    _lowerCAmelCase						(				self    )					->	Optional[Any]:
				if not self.test_rust_tokenizer:
					return

				_lowerCAmelCase								=self.get_tokenizer()
				_lowerCAmelCase								=self.get_rust_tokenizer()

				_lowerCAmelCase								="""UNwant\u00E9d,running"""

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

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

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

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

				_lowerCAmelCase								="""UNwant\u00E9d,running"""

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

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

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



			def    _lowerCAmelCase						(				self    )					->	Union[str, Any]:
				_lowerCAmelCase								=BasicTokenizer()

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



			def    _lowerCAmelCase						(				self    )					->	Tuple:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	str:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase	,	strip_accents=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	str:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase	,	strip_accents=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	List[Any]:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	List[Any]:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	str:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase	,	strip_accents=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	Dict:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase	,	strip_accents=__UpperCAmelCase    )

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



			def    _lowerCAmelCase						(				self    )					->	Any:
				_lowerCAmelCase								=BasicTokenizer(do_lower_case=__UpperCAmelCase	,	never_split=["""[UNK]"""]    )

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



			def    _lowerCAmelCase						(				self    )					->	str:
				_lowerCAmelCase								=["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]

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

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

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



			@slow
			def    _lowerCAmelCase						(				self    )					->	List[Any]:
				_lowerCAmelCase								=self.tokenizer_class.from_pretrained("""google/electra-base-discriminator"""    )

				_lowerCAmelCase								=tokenizer.encode("""sequence builders"""	,	add_special_tokens=__UpperCAmelCase    )
				_lowerCAmelCase								=tokenizer.encode("""multi-sequence build"""	,	add_special_tokens=__UpperCAmelCase    )

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

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



			def    _lowerCAmelCase						(				self    )					->	int:
				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
					with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
						_lowerCAmelCase								=self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase	,	**__UpperCAmelCase    )

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

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

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

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

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

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

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

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

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





"""simple docstring"""


import math



def        _lowerCamelCase(__UpperCamelCase			)							->					bool:

	if 1 < number < 4:
		# 2 and 3 are primes
		return True
	elif number < 2 or number % 2 == 0 or number % 3 == 0:
		# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
		return False

	# All primes number are in format of 6k +/- 1
	for i in range(5       ,					int(math.sqrt(__UpperCamelCase			) + 1			)       ,					6			):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True



def        _lowerCamelCase(__UpperCamelCase = 600851475143			)							->					int:

	try:
		_lowerCAmelCase								=int(__UpperCamelCase			)
	except (TypeError, ValueError):
		raise TypeError("""Parameter n must be int or castable to int."""			)
	if n <= 0:
		raise ValueError("""Parameter n must be greater than or equal to one."""			)
	_lowerCAmelCase								=0
	if is_prime(__UpperCamelCase			):
		return n
	while n % 2 == 0:
		n //= 2
	if is_prime(__UpperCamelCase			):
		return n
	for i in range(3       ,					int(math.sqrt(__UpperCamelCase			)			) + 1       ,					2			):
		if n % i == 0:
			if is_prime(n // i			):
				_lowerCAmelCase								=n // i
				break
			elif is_prime(__UpperCamelCase			):
				_lowerCAmelCase								=i
	return max_number


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



