import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import ViTImageProcessor



class      _A (     unittest.TestCase				):






  def __init__(self ,					SCREAMING_SNAKE_CASE_ ,					SCREAMING_SNAKE_CASE_=13 ,					SCREAMING_SNAKE_CASE_=3 ,					SCREAMING_SNAKE_CASE_=224 ,					SCREAMING_SNAKE_CASE_=30 ,					SCREAMING_SNAKE_CASE_=400 ,					SCREAMING_SNAKE_CASE_=True ,					SCREAMING_SNAKE_CASE_=None ,					SCREAMING_SNAKE_CASE_=True ,					SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5] ,					SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5] ,					)		->   Dict:





       '''simple docstring'''





       UpperCamelCase__					    =   size if size is not None else {'''height''': 18, '''width''': 18}
       UpperCamelCase__					    =   parent
       UpperCamelCase__					    =   batch_size
       UpperCamelCase__					    =   num_channels
       UpperCamelCase__					    =   image_size
       UpperCamelCase__					    =   min_resolution
       UpperCamelCase__					    =   max_resolution
       UpperCamelCase__					    =   do_resize
       UpperCamelCase__					    =   size
       UpperCamelCase__					    =   do_normalize
       UpperCamelCase__					    =   image_mean
       UpperCamelCase__					    =   image_std






  def 		_a       (self						)		->   Union[str, Any]:





       '''simple docstring'''





       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
       }



@require_torch
@require_vision
class      _A (     lowercase_						,			unittest.TestCase				):
  SCREAMING_SNAKE_CASE_						:						int    =ViTImageProcessor if is_vision_available() else None






  def 		_a       (self						)		->   Any:





       '''simple docstring'''





       UpperCamelCase__					    =   EfficientFormerImageProcessorTester(self						)






  @property
  def 		_a       (self						)		->   int:





       '''simple docstring'''





       return self.image_proc_tester.prepare_image_processor_dict()






  def 		_a       (self						)		->   Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__					    =   self.image_processing_class(**self.image_processor_dict						)
       self.assertTrue(hasattr(_lowercase ,					'''image_mean'''						)						)
       self.assertTrue(hasattr(_lowercase ,					'''image_std'''						)						)
       self.assertTrue(hasattr(_lowercase ,					'''do_normalize'''						)						)
       self.assertTrue(hasattr(_lowercase ,					'''do_resize'''						)						)
       self.assertTrue(hasattr(_lowercase ,					'''size'''						)						)






  def 		_a       (self						)		->   Union[str, Any]:





       '''simple docstring'''





       pass






  def 		_a       (self						)		->   Any:





       '''simple docstring'''





       UpperCamelCase__					    =   self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       UpperCamelCase__					    =   prepare_image_inputs(self.image_proc_tester ,					equal_resolution=_lowercase						)
       for image in image_inputs:
            self.assertIsInstance(_lowercase ,					Image.Image						)

       # Test not batched input
       UpperCamelCase__					    =   image_processor(image_inputs[0] ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               1,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)

       # Test batched
       UpperCamelCase__					    =   image_processor(_lowercase ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               self.image_proc_tester.batch_size,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)






  def 		_a       (self						)		->   Tuple:





       '''simple docstring'''





       UpperCamelCase__					    =   self.image_processing_class(**self.image_processor_dict						)
       # create random numpy tensors
       UpperCamelCase__					    =   prepare_image_inputs(self.image_proc_tester ,					equal_resolution=_lowercase ,					numpify=_lowercase						)
       for image in image_inputs:
            self.assertIsInstance(_lowercase ,					np.ndarray						)

       # Test not batched input
       UpperCamelCase__					    =   image_processor(image_inputs[0] ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               1,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)

       # Test batched
       UpperCamelCase__					    =   image_processor(_lowercase ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               self.image_proc_tester.batch_size,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)






  def 		_a       (self						)		->   Tuple:





       '''simple docstring'''





       UpperCamelCase__					    =   self.image_processing_class(**self.image_processor_dict						)
       # create random PyTorch tensors
       UpperCamelCase__					    =   prepare_image_inputs(self.image_proc_tester ,					equal_resolution=_lowercase ,					torchify=_lowercase						)
       for image in image_inputs:
            self.assertIsInstance(_lowercase ,					torch.Tensor						)

       # Test not batched input
       UpperCamelCase__					    =   image_processor(image_inputs[0] ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               1,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)

       # Test batched
       UpperCamelCase__					    =   image_processor(_lowercase ,					return_tensors='''pt'''						).pixel_values
       self.assertEqual(
           encoded_images.shape ,					(
               self.image_proc_tester.batch_size,
               self.image_proc_tester.num_channels,
               self.image_proc_tester.size['''height'''],
               self.image_proc_tester.size['''width'''],
           ) ,					)






'''simple docstring'''

def 							_UpperCamelCase				(   lowerCAmelCase__:					str   )      -> bool:
							return credit_card_number.startswith(('34', '35', '37', '4', '5', '6')   )




def 							_UpperCamelCase				(   lowerCAmelCase__:					str   )      -> bool:
							SCREAMING_SNAKE_CASE_				=				credit_card_number
							SCREAMING_SNAKE_CASE_				=				0
							SCREAMING_SNAKE_CASE_				=				len(lowerCAmelCase__   ) - 2
							for i in range(lowerCAmelCase__		,-1		,-2   ):
														#  double the value of every second digit
														SCREAMING_SNAKE_CASE_				=				int(cc_number[i]   )
														digit *= 2
														# If doubling of a number results in a two digit number
														# i.e greater than 9(e.g., 6 × 2 = 12),
														# then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6),
														# to get a single digit number.
														if digit > 9:
																					digit %= 10
																					digit += 1
														SCREAMING_SNAKE_CASE_				=				cc_number[:i] + str(lowerCAmelCase__   ) + cc_number[i + 1 :]
														total += digit

							# Sum up the remaining digits
							for i in range(len(lowerCAmelCase__   ) - 1		,-1		,-2   ):
														total += int(cc_number[i]   )

							return total % 10 == 0




def 							_UpperCamelCase				(   lowerCAmelCase__:					str   )      -> bool:
							SCREAMING_SNAKE_CASE_				=				F"""{credit_card_number} is an invalid credit card number because"""
							if not credit_card_number.isdigit():
														print(F"""{error_message} it has nonnumerical characters."""   )
														return False

							if not 13 <= len(lowerCAmelCase__   ) <= 16:
														print(F"""{error_message} of its length."""   )
														return False

							if not validate_initial_digits(lowerCAmelCase__   ):
														print(F"""{error_message} of its first two digits."""   )
														return False

							if not luhn_validation(lowerCAmelCase__   ):
														print(F"""{error_message} it fails the Luhn check."""   )
														return False

							print(F"""{credit_card_number} is a valid credit card number."""   )
							return True


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							validate_credit_card_number("4111111111111111")
							validate_credit_card_number("32323")





