






"""simple docstring"""





import math
import unittest







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






class 	a		(   unittest.TestCase						):






    def   UpperCamelCase			(			self	:				int   )	->						int:
      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	:				List[str]   )	->						List[str]:
      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"""





from transformers import DistilBertTokenizer, DistilBertTokenizerFast
from transformers.testing_utils import require_tokenizers, slow

from ..bert.test_tokenization_bert import BertTokenizationTest






@require_tokenizers
class 	a		(   __snake_case						):
    SCREAMING_SNAKE_CASE		:	Optional[Any]		=					DistilBertTokenizer
    SCREAMING_SNAKE_CASE		:	Optional[Any]		=					DistilBertTokenizerFast
    SCREAMING_SNAKE_CASE		:	int		=					True






    @slow
    def   UpperCamelCase			(			self	:				Optional[int]   )	->						int:
      lowerCamelCase_       	=		DistilBertTokenizer.from_pretrained('distilbert-base-uncased'   )

      lowerCamelCase_       	=		tokenizer.encode('sequence builders'			,		add_special_tokens=__SCREAMING_SNAKE_CASE   )
      lowerCamelCase_       	=		tokenizer.encode('multi-sequence build'			,		add_special_tokens=__SCREAMING_SNAKE_CASE   )

      lowerCamelCase_       	=		tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE   )
      lowerCamelCase_       	=		tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE			,		__SCREAMING_SNAKE_CASE   )

      assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
      assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
          tokenizer.sep_token_id
      ]




