
import math
import unittest


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







class 			__A( unittest.TestCase			):




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


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


								'''simple docstring'''




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

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A     :	Optional[int]    = {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	int    = ['WhisperTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	str    = [
					    'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'WhisperForConditionalGeneration',
					    'WhisperModel',
					    'WhisperPreTrainedModel',
					    'WhisperForAudioClassification',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	Tuple    = [
					    'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFWhisperForConditionalGeneration',
					    'TFWhisperModel',
					    'TFWhisperPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A     :	int    = [
					    'FlaxWhisperForConditionalGeneration',
					    'FlaxWhisperModel',
					    'FlaxWhisperPreTrainedModel',
					    'FlaxWhisperForAudioClassification',
					]


if TYPE_CHECKING:
					from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
					from .feature_extraction_whisper import WhisperFeatureExtractor
					from .processing_whisper import WhisperProcessor
					from .tokenization_whisper import WhisperTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_whisper_fast import WhisperTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_whisper import (
										    WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    WhisperForAudioClassification,
										    WhisperForConditionalGeneration,
										    WhisperModel,
										    WhisperPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_whisper import (
										    TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFWhisperForConditionalGeneration,
										    TFWhisperModel,
										    TFWhisperPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_whisper import (
										    FlaxWhisperForAudioClassification,
										    FlaxWhisperForConditionalGeneration,
										    FlaxWhisperModel,
										    FlaxWhisperPreTrainedModel,
										)

else:
					import sys

					A     :	Tuple    = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)