'''simple docstring'''




import tempfile
import unittest

from make_student import create_student_by_copying_alternating_layers

from transformers import AutoConfig
from transformers.file_utils import cached_property
from transformers.testing_utils import require_torch


_lowercase						: Optional[int]						=						"sshleifer/bart-tiny-random"
_lowercase						: str						=						"patrickvonplaten/t5-tiny-random"





@require_torch
class     __magic_name__						(    unittest.TestCase):







			@cached_property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Tuple    ):
										return AutoConfig.from_pretrained(lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_						,						*lowercase_					:			Optional[int]										=       create_student_by_copying_alternating_layers(lowercase_				,			tempfile.mkdtemp()				,			e=1				,			d=1    )
										self.assertEqual(student.config.num_hidden_layers				,			1    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_						,						*lowercase_					:			List[str]										=       create_student_by_copying_alternating_layers(lowercase_				,			tempfile.mkdtemp()				,			e=1				,			d=lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_						,						*lowercase_					:			Union[str, Any]										=       create_student_by_copying_alternating_layers(lowercase_				,			tempfile.mkdtemp()				,			e=1				,			d=lowercase_    )
										self.assertEqual(student.config.encoder_layers				,			1    )
										self.assertEqual(student.config.decoder_layers				,			self.teacher_config.encoder_layers    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[str]    ):
										lowercase_						,						*lowercase_					:			str										=       create_student_by_copying_alternating_layers(lowercase_				,			tempfile.mkdtemp()				,			e=1				,			d=1    )
										self.assertEqual(student.config.encoder_layers				,			1    )
										self.assertEqual(student.config.decoder_layers				,			1    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										with self.assertRaises(lowercase_    ):
																	create_student_by_copying_alternating_layers(lowercase_				,			tempfile.mkdtemp()				,			e=lowercase_				,			d=lowercase_    )






'''simple docstring'''




import math
import unittest




def 							lowerCamelCase	(      UpperCAmelCase__       :					int )			->      bool:
							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     __magic_name__						(    unittest.TestCase):







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict    ):
										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 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]    ):
										with self.assertRaises(lowercase_    ):
																	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()





