





def      _A       (		SCREAMING_SNAKE_CASE     :   str						):





  """simple docstring"""



  return credit_card_number.startswith(("34", "35", "37", "4", "5", "6")						)
def      _A       (		SCREAMING_SNAKE_CASE     :   str						):





  """simple docstring"""



  a__	:					Tuple										=credit_card_number
  a__	:					Union[str, Any]										=0
  a__	:					List[str]										=len(SCREAMING_SNAKE_CASE						) - 2
  for i in range(SCREAMING_SNAKE_CASE       ,       -1       ,       -2						):
    #  double the value of every second digit
    a__	:					List[Any]										=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
    a__	:					List[str]										=cc_number[:i] + str(SCREAMING_SNAKE_CASE						) + cc_number[i + 1 :]
    total += digit

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

  return total % 10 == 0
def      _A       (		SCREAMING_SNAKE_CASE     :   str						):





  """simple docstring"""



  a__	:					List[Any]										=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(SCREAMING_SNAKE_CASE						) <= 16:
    print(f'''{error_message} of its length.'''						)
    return False

  if not validate_initial_digits(SCREAMING_SNAKE_CASE						):
    print(f'''{error_message} of its first two digits.'''						)
    return False

  if not luhn_validation(SCREAMING_SNAKE_CASE						):
    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""")










import gc
import inspect
import unittest

import torch
from parameterized import parameterized

from diffusers import PriorTransformer
from diffusers.utils import floats_tensor, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin


enable_full_determinism()





class       A    (   A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Any       =PriorTransformer
							UpperCamelCase_   :							List[str]       ='''hidden_states'''


							@property
							def 			_A       (self					):
									__lowercase=			4
									__lowercase=			8
									__lowercase=			7

									__lowercase=			floats_tensor((batch_size, embedding_dim)					).to(lowerCAmelCase					)

									__lowercase=			floats_tensor((batch_size, embedding_dim)					).to(lowerCAmelCase					)
									__lowercase=			floats_tensor((batch_size, num_embeddings, embedding_dim)					).to(lowerCAmelCase					)

									return {
									    "hidden_states": hidden_states,
									    "timestep": 2,
									    "proj_embedding": proj_embedding,
									    "encoder_hidden_states": encoder_hidden_states,
									}


							def 			_A       (self      ,				lowerCAmelCase=0					):
									torch.manual_seed(lowerCAmelCase					)
									__lowercase=			4
									__lowercase=			8
									__lowercase=			7

									__lowercase=			torch.randn((batch_size, embedding_dim)					).to(lowerCAmelCase					)

									__lowercase=			torch.randn((batch_size, embedding_dim)					).to(lowerCAmelCase					)
									__lowercase=			torch.randn((batch_size, num_embeddings, embedding_dim)					).to(lowerCAmelCase					)

									return {
									    "hidden_states": hidden_states,
									    "timestep": 2,
									    "proj_embedding": proj_embedding,
									    "encoder_hidden_states": encoder_hidden_states,
									}


							@property
							def 			_A       (self					):
									return (4, 8)


							@property
							def 			_A       (self					):
									return (4, 8)


							def 			_A       (self					):
									__lowercase=			{
									    'num_attention_heads': 2,
									    'attention_head_dim': 4,
									    'num_layers': 2,
									    'embedding_dim': 8,
									    'num_embeddings': 7,
									    'additional_embeddings': 4,
									}
									__lowercase=			self.dummy_input
									return init_dict, inputs_dict


							def 			_A       (self					):
									__lowercase,							__lowercase=			PriorTransformer.from_pretrained(
									    'hf-internal-testing/prior-dummy'      ,				output_loading_info=lowerCAmelCase					)
									self.assertIsNotNone(lowerCAmelCase					)
									self.assertEqual(len(loading_info['missing_keys']					)      ,				0					)

									model.to(lowerCAmelCase					)
									__lowercase=			model(**self.dummy_input					)[0]

									assert hidden_states is not None, "Make sure output is not None"


							def 			_A       (self					):
									__lowercase,							__lowercase=			self.prepare_init_args_and_inputs_for_common()

									__lowercase=			self.model_class(**lowerCAmelCase					)
									__lowercase=			inspect.signature(model.forward					)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									__lowercase=			[*signature.parameters.keys()]

									__lowercase=			['hidden_states', 'timestep']
									self.assertListEqual(arg_names[:2]      ,				lowerCAmelCase					)







							def 			_A       (self					):
									__lowercase=			PriorTransformer.from_pretrained('hf-internal-testing/prior-dummy'					)
									__lowercase=			model.to(lowerCAmelCase					)

									if hasattr(lowerCAmelCase      ,				'set_default_attn_processor'					):
											model.set_default_attn_processor()

									__lowercase=			self.get_dummy_seed_input()

									with torch.no_grad():
											__lowercase=			model(**lowerCAmelCase					)[0]

									__lowercase=			output[0, :5].flatten().cpu()
									print(lowerCAmelCase					)

									# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
									# the expected output slices are not the same for CPU and GPU.
									__lowercase=			torch.tensor([-1.34_36, -0.28_70, 0.75_38, 0.43_68, -0.02_39]					)
									self.assertTrue(torch_all_close(lowerCAmelCase      ,				lowerCAmelCase      ,				rtol=1E-2					)					)





@slow
class       A    (   unittest.TestCase ):


							def 			_A       (self      ,				lowerCAmelCase=1      ,				lowerCAmelCase=7_6_8      ,				lowerCAmelCase=7_7      ,				lowerCAmelCase=0					):
									torch.manual_seed(lowerCAmelCase					)
									__lowercase=			batch_size
									__lowercase=			embedding_dim
									__lowercase=			num_embeddings

									__lowercase=			torch.randn((batch_size, embedding_dim)					).to(lowerCAmelCase					)

									__lowercase=			torch.randn((batch_size, embedding_dim)					).to(lowerCAmelCase					)
									__lowercase=			torch.randn((batch_size, num_embeddings, embedding_dim)					).to(lowerCAmelCase					)

									return {
									    "hidden_states": hidden_states,
									    "timestep": 2,
									    "proj_embedding": proj_embedding,
									    "encoder_hidden_states": encoder_hidden_states,
									}


							def 			_A       (self					):
									# clean up the VRAM after each test
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







							@parameterized.expand(
							    [
							        # fmt: off
							        [1_3, [-0.58_61,  0.12_83, -0.09_31,  0.08_82,  0.44_76,  0.13_29, -0.04_98,  0.06_40]],
							        [3_7, [-0.49_13,  0.01_10, -0.04_83,  0.05_41,  0.49_54, -0.01_70,  0.03_54,  0.16_51]],
							        # fmt: on
							    ]					)
							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			PriorTransformer.from_pretrained('kandinsky-community/kandinsky-2-1-prior'      ,				subfolder='prior'					)
									model.to(lowerCAmelCase					)
									__lowercase=			self.get_dummy_seed_input(seed=lowerCAmelCase					)

									with torch.no_grad():
											__lowercase=			model(**lowerCAmelCase					)[0]

									assert list(sample.shape					) == [1, 7_6_8]

									__lowercase=			sample[0, :8].flatten().cpu()
									print(lowerCAmelCase					)
									__lowercase=			torch.tensor(lowerCAmelCase					)

									assert torch_all_close(lowerCAmelCase      ,				lowerCAmelCase      ,				atol=1E-3					)






