
'''simple docstring'''





import math
import unittest

def      A (       A_							:					int       ):
						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 	__snake_case							(							self	:				str      ):
										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 	__snake_case							(							self	:				List[Any]      ):
										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()





'''simple docstring'''





import os
import sys

UpperCAmelCase    					=   os.path.join(os.path.dirname(__file__), "src")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


UpperCAmelCase    					=   [
    "torch",
    "numpy",
    "tokenizers",
    "filelock",
    "requests",
    "tqdm",
    "regex",
    "sentencepiece",
    "sacremoses",
    "importlib_metadata",
    "huggingface_hub",
]

@add_start_docstrings(AutoConfig.__doc__       )
def      A (       *A_							:					Optional[Any]    ,							**A_							:					List[str]       ):
						return AutoConfig.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoTokenizer.__doc__       )
def      A (       *A_							:					Dict    ,							**A_							:					str       ):
						return AutoTokenizer.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModel.__doc__       )
def      A (       *A_							:					Union[str, Any]    ,							**A_							:					Optional[Any]       ):
						return AutoModel.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForCausalLM.__doc__       )
def      A (       *A_							:					str    ,							**A_							:					Optional[Any]       ):
						return AutoModelForCausalLM.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForMaskedLM.__doc__       )
def      A (       *A_							:					List[str]    ,							**A_							:					Optional[Any]       ):
						return AutoModelForMaskedLM.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForSequenceClassification.__doc__       )
def      A (       *A_							:					Tuple    ,							**A_							:					List[str]       ):
						return AutoModelForSequenceClassification.from_pretrained(*A_    ,							**A_       )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__       )
def      A (       *A_							:					Tuple    ,							**A_							:					Any       ):
						return AutoModelForQuestionAnswering.from_pretrained(*A_    ,							**A_       )

