





import math
import unittest





def 						lowerCamelCase__     (     UpperCamelCase__			:       int						)			-> bool:



     '''simple docstring'''




     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 	lowerCAmelCase			(		self  )		->							Optional[Any]:
          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 	lowerCAmelCase			(		self  )		->							Tuple:
          with self.assertRaises(lowerCAmelCase_  ):
               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()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_      							=     {
    """configuration_bigbird_pegasus""": [
        """BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BigBirdPegasusConfig""",
        """BigBirdPegasusOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase_      							=     [
					    """BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """BigBirdPegasusForCausalLM""",
					    """BigBirdPegasusForConditionalGeneration""",
					    """BigBirdPegasusForQuestionAnswering""",
					    """BigBirdPegasusForSequenceClassification""",
					    """BigBirdPegasusModel""",
					    """BigBirdPegasusPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_bigbird_pegasus import (
					    BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    BigBirdPegasusConfig,
					    BigBirdPegasusOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_bigbird_pegasus import (
										    BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
										    BigBirdPegasusForCausalLM,
										    BigBirdPegasusForConditionalGeneration,
										    BigBirdPegasusForQuestionAnswering,
										    BigBirdPegasusForSequenceClassification,
										    BigBirdPegasusModel,
										    BigBirdPegasusPreTrainedModel,
										)


else:
					import sys

					UpperCAmelCase_      							=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



