
"""simple docstring"""




import json
import os
import unittest

from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast
from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class 	lowerCAmelCase_						(a__ ,					unittest.TestCase  ):


				"""simple docstring"""



				__UpperCamelCase      :						List[Any]					       =   LEDTokenizer
				__UpperCamelCase      :						Dict					       =   LEDTokenizerFast
				__UpperCamelCase      :						str					       =   True



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											super().setUp()
											SCREAMING_SNAKE_CASE__						:       int           =   [
											    """l""",
											    """o""",
											    """w""",
											    """e""",
											    """r""",
											    """s""",
											    """t""",
											    """i""",
											    """d""",
											    """n""",
											    """\u0120""",
											    """\u0120l""",
											    """\u0120n""",
											    """\u0120lo""",
											    """\u0120low""",
											    """er""",
											    """\u0120lowest""",
											    """\u0120newer""",
											    """\u0120wider""",
											    """<unk>""",
											]
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   dict(zip(SCREAMING_SNAKE_CASE__   ,       range(len(SCREAMING_SNAKE_CASE__    )    )    )    )
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
											SCREAMING_SNAKE_CASE__						:       List[str]           =   {"""unk_token""": """<unk>"""}

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   os.path.join(self.tmpdirname   ,       VOCAB_FILES_NAMES["""vocab_file"""]    )
											SCREAMING_SNAKE_CASE__						:       Any           =   os.path.join(self.tmpdirname   ,       VOCAB_FILES_NAMES["""merges_file"""]    )
											with open(self.vocab_file   ,       """w"""   ,       encoding="""utf-8"""    ) as fp:
																		fp.write(json.dumps(SCREAMING_SNAKE_CASE__    ) + """\n"""    )
											with open(self.merges_file   ,       """w"""   ,       encoding="""utf-8"""    ) as fp:
																		fp.write("""\n""".join(SCREAMING_SNAKE_CASE__    )    )



				def 	__magic_name__    (self   ,       **SCREAMING_SNAKE_CASE__    )					->		Optional[int]:



											"""simple docstring"""




											kwargs.update(self.special_tokens_map    )
											return self.tokenizer_class.from_pretrained(self.tmpdirname   ,       **SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self   ,       **SCREAMING_SNAKE_CASE__    )					->		Dict:



											"""simple docstring"""




											kwargs.update(self.special_tokens_map    )
											return self.rust_tokenizer_class.from_pretrained(self.tmpdirname   ,       **SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											return "lower newer", "lower newer"



				@cached_property
				def 	__magic_name__    (self    )					->		Tuple:



											"""simple docstring"""




											return LEDTokenizer.from_pretrained("""allenai/led-base-16384"""    )



				@cached_property
				def 	__magic_name__    (self    )					->		Tuple:



											"""simple docstring"""




											return LEDTokenizerFast.from_pretrained("""allenai/led-base-16384"""    )



				@require_torch
				def 	__magic_name__    (self    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Dict           =   ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
											SCREAMING_SNAKE_CASE__						:       int           =   [0, 2_50, 2_51, 1_78_18, 13, 3_91_86, 19_38, 4, 2]

											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       List[str]           =   tokenizer(SCREAMING_SNAKE_CASE__   ,       max_length=len(SCREAMING_SNAKE_CASE__    )   ,       padding=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
																		self.assertIsInstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )

																		self.assertEqual((2, 9)   ,       batch.input_ids.shape    )
																		self.assertEqual((2, 9)   ,       batch.attention_mask.shape    )
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   batch.input_ids.tolist()[0]
																		self.assertListEqual(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )



				@require_torch
				def 	__magic_name__    (self    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   tokenizer(SCREAMING_SNAKE_CASE__   ,       padding=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
																		self.assertIn("""input_ids"""   ,       SCREAMING_SNAKE_CASE__    )
																		self.assertIn("""attention_mask"""   ,       SCREAMING_SNAKE_CASE__    )
																		self.assertNotIn("""labels"""   ,       SCREAMING_SNAKE_CASE__    )
																		self.assertNotIn("""decoder_attention_mask"""   ,       SCREAMING_SNAKE_CASE__    )



				@require_torch
				def 	__magic_name__    (self    )					->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       str           =   [
											    """Summary of the text.""",
											    """Another summary.""",
											]
											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       str           =   tokenizer(text_target=SCREAMING_SNAKE_CASE__   ,       max_length=32   ,       padding="""max_length"""   ,       return_tensors="""pt"""    )
																		self.assertEqual(32   ,       targets["""input_ids"""].shape[1]    )



				@require_torch
				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   tokenizer(
																		    ["""I am a small frog""" * 10_24, """I am a small frog"""]   ,       padding=SCREAMING_SNAKE_CASE__   ,       truncation=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
																		self.assertIsInstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
																		self.assertEqual(batch.input_ids.shape   ,       (2, 51_22)    )



				@require_torch
				def 	__magic_name__    (self    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[Any]           =   ["""A long paragraph for summarization."""]
											SCREAMING_SNAKE_CASE__						:       List[str]           =   [
											    """Summary of the text.""",
											]
											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   tokenizer(SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
																		SCREAMING_SNAKE_CASE__						:       Any           =   tokenizer(text_target=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    )
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   inputs["""input_ids"""]
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   targets["""input_ids"""]
																		self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()    )
																		self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()    )
																		self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()    )
																		self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()    )



				@require_torch
				def 	__magic_name__    (self    )					->		Optional[Any]:



											"""simple docstring"""




											for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
																		SCREAMING_SNAKE_CASE__						:       Any           =   ["""Summary of the text.""", """Another summary."""]
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]]

																		SCREAMING_SNAKE_CASE__						:       int           =   tokenizer(SCREAMING_SNAKE_CASE__   ,       padding=SCREAMING_SNAKE_CASE__    )
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [[0] * len(SCREAMING_SNAKE_CASE__    ) for x in encoded_output["""input_ids"""]]
																		SCREAMING_SNAKE_CASE__						:       str           =   tokenizer.pad(SCREAMING_SNAKE_CASE__    )
																		self.assertSequenceEqual(outputs["""global_attention_mask"""]   ,       SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		str:



											"""simple docstring"""




											pass



				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																									SCREAMING_SNAKE_CASE__						:       List[str]           =   self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )
																									SCREAMING_SNAKE_CASE__						:       int           =   self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )
																									SCREAMING_SNAKE_CASE__						:       int           =   """A, <mask> AllenNLP sentence."""
																									SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE__   ,       add_special_tokens=SCREAMING_SNAKE_CASE__   ,       return_token_type_ids=SCREAMING_SNAKE_CASE__    )
																									SCREAMING_SNAKE_CASE__						:       Tuple           =   tokenizer_p.encode_plus(SCREAMING_SNAKE_CASE__   ,       add_special_tokens=SCREAMING_SNAKE_CASE__   ,       return_token_type_ids=SCREAMING_SNAKE_CASE__    )
																									self.assertEqual(sum(tokens_r["""token_type_ids"""]    )   ,       sum(tokens_p["""token_type_ids"""]    )    )
																									self.assertEqual(
																									    sum(tokens_r["""attention_mask"""]    ) / len(tokens_r["""attention_mask"""]    )   ,       sum(tokens_p["""attention_mask"""]    ) / len(tokens_p["""attention_mask"""]    )   ,       )

																									SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]    )
																									SCREAMING_SNAKE_CASE__						:       str           =   tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]    )
																									self.assertSequenceEqual(tokens_p["""input_ids"""]   ,       [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]    )
																									self.assertSequenceEqual(tokens_r["""input_ids"""]   ,       [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]    )

																									self.assertSequenceEqual(
																									    SCREAMING_SNAKE_CASE__   ,       ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]    )
																									self.assertSequenceEqual(
																									    SCREAMING_SNAKE_CASE__   ,       ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]    )






"""simple docstring"""




import math
import unittest

def lowercase_  (   _snake_case						):
							assert isinstance(_snake_case   ,_snake_case						) and (
							    number >= 0
							), "'number' must been an int and positive"

							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(_snake_case						) + 1						)   ,6						):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True



class 	lowerCAmelCase_						(unittest.TestCase  ):


				"""simple docstring"""



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											self.assertTrue(is_prime(2    )    )
											self.assertTrue(is_prime(3    )    )
											self.assertTrue(is_prime(5    )    )
											self.assertTrue(is_prime(7    )    )
											self.assertTrue(is_prime(11    )    )
											self.assertTrue(is_prime(13    )    )
											self.assertTrue(is_prime(17    )    )
											self.assertTrue(is_prime(19    )    )
											self.assertTrue(is_prime(23    )    )
											self.assertTrue(is_prime(29    )    )



				def 	__magic_name__    (self    )					->		List[Any]:



											"""simple docstring"""




											with self.assertRaises(SCREAMING_SNAKE_CASE__    ):
																		is_prime(-19    )
											self.assertFalse(
											    is_prime(0    )   ,       """Zero doesn't have any positive factors, primes must have exactly two."""   ,       )
											self.assertFalse(
											    is_prime(1    )   ,       """One only has 1 positive factor, primes must have exactly two."""   ,       )
											self.assertFalse(is_prime(2 * 2    )    )
											self.assertFalse(is_prime(2 * 3    )    )
											self.assertFalse(is_prime(3 * 3    )    )
											self.assertFalse(is_prime(3 * 5    )    )
											self.assertFalse(is_prime(3 * 5 * 7    )    )


if __name__ == "__main__":
					unittest.main()




