


import math
import unittest


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







class        UpperCamelCase__   (	unittest.TestCase   ):

					def   UpperCAmelCase__       (     self       :   str       ):






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






										'''simple docstring'''






										with self.assertRaises(UpperCamelCase__       ):
															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()






import torch
import torch.nn as nn
from transformers.modeling_utils import ModuleUtilsMixin
from transformers.models.ta.modeling_ta import TaBlock, TaConfig, TaLayerNorm

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin







class        UpperCamelCase__   (	__magic_name__							,				__magic_name__							,				__magic_name__   ):

					@register_to_config
					def __init__(     self       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   float							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   bool = False							,					):






										'''simple docstring'''






										super().__init__()

										lowercase_  							=			nn.Embedding(UpperCamelCase__							,					UpperCamelCase__       )

										lowercase_  							=			nn.Embedding(UpperCamelCase__							,					UpperCamelCase__       )
										lowercase_  							=			False

										lowercase_  							=			nn.Dropout(p=UpperCamelCase__       )

										lowercase_  							=			TaConfig(
										    vocab_size=UpperCamelCase__							,					d_model=UpperCamelCase__							,					num_heads=UpperCamelCase__							,					d_kv=UpperCamelCase__							,					d_ff=UpperCamelCase__							,					dropout_rate=UpperCamelCase__							,					feed_forward_proj=UpperCamelCase__							,					is_decoder=UpperCamelCase__							,					is_encoder_decoder=UpperCamelCase__							,					)

										lowercase_  							=			nn.ModuleList()
										for lyr_num in range(UpperCamelCase__       ):
															lowercase_  							=			TaBlock(UpperCamelCase__       )
															self.encoders.append(UpperCamelCase__       )

										lowercase_  							=			TaLayerNorm(UpperCamelCase__       )
										lowercase_  							=			nn.Dropout(p=UpperCamelCase__       )







					def   UpperCAmelCase__       (     self       :   Optional[Any]							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   str       ):






										'''simple docstring'''






										lowercase_  							=			self.token_embedder(UpperCamelCase__       )

										lowercase_  							=			encoder_input_tokens.shape[1]
										lowercase_  							=			torch.arange(UpperCamelCase__							,					device=encoder_input_tokens.device       )
										x += self.position_encoding(UpperCamelCase__       )

										lowercase_  							=			self.dropout_pre(UpperCamelCase__       )

										# inverted the attention mask
										lowercase_  							=			encoder_input_tokens.size()
										lowercase_  							=			self.get_extended_attention_mask(UpperCamelCase__							,					UpperCamelCase__       )

										for lyr in self.encoders:
															lowercase_  							=			lyr(UpperCamelCase__							,					UpperCamelCase__       )[0]
										lowercase_  							=			self.layer_norm(UpperCamelCase__       )

										return self.dropout_post(UpperCamelCase__       ), encoder_inputs_mask


