
import math
import unittest

def 		UpperCamelCase						(   lowercase_ )		->						bool:


  '''simple docstring'''






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



class    _snake_case (						unittest.TestCase				):


 def   lowercase__  (       self):


   '''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   lowercase__  (       self):


   '''simple docstring'''




   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()








from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding



class    _snake_case (						UpperCAmelCase_				):
 __lowerCAmelCase	:  Any	   =      ['image_processor', 'tokenizer']
 __lowerCAmelCase	:  Union[str, Any]	   =      'AutoImageProcessor'
 __lowerCAmelCase	:  int	   =      'AutoTokenizer'


 def __init__(       self       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   super().__init__(SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_)
   lowercase__	: Union[str, Any]     		=   self.image_processor


 def __call__(       self       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_=None       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   if text is None and images is None:
     raise ValueError("""You have to specify either text or images. Both cannot be none.""")

   if text is not None:
     lowercase__	: List[str]     		=   self.tokenizer(SCREAMING_SNAKE_CASE_       ,	return_tensors=SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)

   if images is not None:
     lowercase__	: Optional[int]     		=   self.image_processor(SCREAMING_SNAKE_CASE_       ,	return_tensors=SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)

   if text is not None and images is not None:
     lowercase__	: Union[str, Any]     		=   image_features.pixel_values
     return encoding
   elif text is not None:
     return encoding
   else:
     return BatchEncoding(data=dict(**SCREAMING_SNAKE_CASE_)       ,	tensor_type=SCREAMING_SNAKE_CASE_)


 def   lowercase__  (       self       ,	*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)


 def   lowercase__  (       self       ,	*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)



 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   return ["input_ids", "attention_mask", "pixel_values"]






