






import gc
import unittest

import numpy as np
import torch
import torch.nn.functional as F
from transformers import (
    ClapTextConfig,
    ClapTextModelWithProjection,
    RobertaTokenizer,
    SpeechTaHifiGan,
    SpeechTaHifiGanConfig,
)

from diffusers import (
    AudioLDMPipeline,
    AutoencoderKL,
    DDIMScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class 			SCREAMING_SNAKE_CASE      (      lowerCAmelCase   ,		unittest.TestCase       ):
     '''simple docstring'''


     UpperCamelCase_				:		Optional[int]								=						AudioLDMPipeline
     UpperCamelCase_				:		Dict								=						TEXT_TO_AUDIO_PARAMS
     UpperCamelCase_				:		Dict								=						TEXT_TO_AUDIO_BATCH_PARAMS
     UpperCamelCase_				:		Union[str, Any]								=						frozenset(
         [
             '''num_inference_steps''',
             '''num_waveforms_per_prompt''',
             '''generator''',
             '''latents''',
             '''output_type''',
             '''return_dict''',
             '''callback''',
             '''callback_steps''',
         ]       )


     def 					_A							(					self							:						Tuple   ):
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   List[str]						    =     UNetaDConditionModel(
           block_out_channels=(32, 64)       ,			layers_per_block=2       ,			sample_size=32       ,			in_channels=4       ,			out_channels=4       ,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")       ,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")       ,			cross_attention_dim=(32, 64)       ,			class_embed_type="simple_projection"       ,			projection_class_embeddings_input_dim=32       ,			class_embeddings_concat=UpperCAmelCase_       ,			)
       SCREAMING_SNAKE_CASE							:   List[str]						    =     DDIMScheduler(
           beta_start=0.00_085       ,			beta_end=0.012       ,			beta_schedule="scaled_linear"       ,			clip_sample=UpperCAmelCase_       ,			set_alpha_to_one=UpperCAmelCase_       ,			)
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   List[str]						    =     AutoencoderKL(
           block_out_channels=[32, 64]       ,			in_channels=1       ,			out_channels=1       ,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]       ,			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]       ,			latent_channels=4       ,			)
       torch.manual_seed(0   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     ClapTextConfig(
           bos_token_id=0       ,			eos_token_id=2       ,			hidden_size=32       ,			intermediate_size=37       ,			layer_norm_eps=1E-05       ,			num_attention_heads=4       ,			num_hidden_layers=5       ,			pad_token_id=1       ,			vocab_size=1000       ,			projection_dim=32       ,			)
       SCREAMING_SNAKE_CASE							:   Dict						    =     ClapTextModelWithProjection(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Tuple						    =     RobertaTokenizer.from_pretrained("hf-internal-testing/tiny-random-roberta"       ,			model_max_length=77   )

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     SpeechTaHifiGanConfig(
           model_in_dim=8       ,			sampling_rate=1_6000       ,			upsample_initial_channel=16       ,			upsample_rates=[2, 2]       ,			upsample_kernel_sizes=[4, 4]       ,			resblock_kernel_sizes=[3, 7]       ,			resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]]       ,			normalize_before=UpperCAmelCase_       ,			)

       SCREAMING_SNAKE_CASE							:   int						    =     SpeechTaHifiGan(UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Any						    =     {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
           "vocoder": vocoder,
       }
       return components


     def 					_A							(					self							:						Optional[Any]       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						Optional[int]=0   ):
       if str(UpperCAmelCase_   ).startswith("mps"   ):
         SCREAMING_SNAKE_CASE							:   str						    =     torch.manual_seed(UpperCAmelCase_   )
       else:
         SCREAMING_SNAKE_CASE							:   Dict						    =     torch.Generator(device=UpperCAmelCase_   ).manual_seed(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     {
           "prompt": "A hammer hitting a wooden surface",
           "generator": generator,
           "num_inference_steps": 2,
           "guidance_scale": 6.0,
       }
       return inputs


     def 					_A							(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     "cpu"  # ensure determinism for the device-dependent torch.Generator

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Tuple						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Tuple						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     output.audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) == 256

       SCREAMING_SNAKE_CASE							:   str						    =     audio[:10]
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     np.array(
           [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033]   )

       assert np.abs(audio_slice - expected_slice   ).max() < 1E-2


     def 					_A							(					self							:						Optional[Any]   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[str]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     3 * [inputs["prompt"]]

       # forward
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     audioldm_pipe(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     output.audios[0]

       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Any						    =     3 * [inputs.pop("prompt"   )]

       SCREAMING_SNAKE_CASE							:   List[str]						    =     audioldm_pipe.tokenizer(
           UpperCAmelCase_       ,			padding="max_length"       ,			max_length=audioldm_pipe.tokenizer.model_max_length       ,			truncation=UpperCAmelCase_       ,			return_tensors="pt"       ,			)
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     text_inputs["input_ids"].to(UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     audioldm_pipe.text_encoder(
           UpperCAmelCase_       ,			)
       SCREAMING_SNAKE_CASE							:   str						    =     prompt_embeds.text_embeds
       # additional L_2 normalization over each hidden-state
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     F.normalize(UpperCAmelCase_       ,			dim=-1   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     prompt_embeds

       # forward
       SCREAMING_SNAKE_CASE							:   Any						    =     audioldm_pipe(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     output.audios[0]

       assert np.abs(audio_a - audio_a   ).max() < 1E-2


     def 					_A							(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   str						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   List[str]						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     3 * ["this is a negative prompt"]
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     negative_prompt
       SCREAMING_SNAKE_CASE							:   str						    =     3 * [inputs["prompt"]]

       # forward
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   int						    =     output.audios[0]

       SCREAMING_SNAKE_CASE							:   str						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     3 * [inputs.pop("prompt"   )]

       SCREAMING_SNAKE_CASE							:   Any						    =     []
       for p in [prompt, negative_prompt]:
         SCREAMING_SNAKE_CASE							:   Any						    =     audioldm_pipe.tokenizer(
             UpperCAmelCase_       ,			padding="max_length"       ,			max_length=audioldm_pipe.tokenizer.model_max_length       ,			truncation=UpperCAmelCase_       ,			return_tensors="pt"       ,			)
         SCREAMING_SNAKE_CASE							:   Dict						    =     text_inputs["input_ids"].to(UpperCAmelCase_   )

         SCREAMING_SNAKE_CASE							:   List[Any]						    =     audioldm_pipe.text_encoder(
             UpperCAmelCase_       ,			)
         SCREAMING_SNAKE_CASE							:   List[Any]						    =     text_embeds.text_embeds
         # additional L_2 normalization over each hidden-state
         SCREAMING_SNAKE_CASE							:   Optional[int]						    =     F.normalize(UpperCAmelCase_       ,			dim=-1   )

         embeds.append(UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     embeds

       # forward
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     output.audios[0]

       assert np.abs(audio_a - audio_a   ).max() < 1E-2


     def 					_A							(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     "cpu"  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE							:   Dict						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     PNDMScheduler(skip_prk_steps=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Any						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     "egg cracking"
       SCREAMING_SNAKE_CASE							:   int						    =     audioldm_pipe(**UpperCAmelCase_       ,			negative_prompt=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Tuple						    =     output.audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) == 256

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     audio[:10]
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     np.array(
           [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032]   )

       assert np.abs(audio_slice - expected_slice   ).max() < 1E-2


     def 					_A							(					self							:						Dict   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     "cpu"  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   int						    =     PNDMScheduler(skip_prk_steps=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     "A hammer hitting a wooden surface"

       # test num_waveforms_per_prompt=1 (default)
       SCREAMING_SNAKE_CASE							:   str						    =     audioldm_pipe(UpperCAmelCase_       ,			num_inference_steps=2   ).audios

       assert audios.shape == (1, 256)

       # test num_waveforms_per_prompt=1 (default) for batch of prompts
       SCREAMING_SNAKE_CASE							:   Any						    =     2
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     audioldm_pipe([prompt] * batch_size       ,			num_inference_steps=2   ).audios

       assert audios.shape == (batch_size, 256)

       # test num_waveforms_per_prompt for single prompt
       SCREAMING_SNAKE_CASE							:   Dict						    =     2
       SCREAMING_SNAKE_CASE							:   Any						    =     audioldm_pipe(UpperCAmelCase_       ,			num_inference_steps=2       ,			num_waveforms_per_prompt=UpperCAmelCase_   ).audios

       assert audios.shape == (num_waveforms_per_prompt, 256)

       # test num_waveforms_per_prompt for batch of prompts
       SCREAMING_SNAKE_CASE							:   List[str]						    =     2
       SCREAMING_SNAKE_CASE							:   Tuple						    =     audioldm_pipe(
           [prompt] * batch_size       ,			num_inference_steps=2       ,			num_waveforms_per_prompt=UpperCAmelCase_   ).audios

       assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)


     def 					_A							(					self							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     "cpu"  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Dict						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   int						    =     audioldm_pipe.vocoder.config.sampling_rate

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.get_dummy_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     audioldm_pipe(audio_length_in_s=0.016       ,			**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     output.audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) / vocoder_sampling_rate == 0.016

       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     audioldm_pipe(audio_length_in_s=0.032       ,			**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     output.audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) / vocoder_sampling_rate == 0.032


     def 					_A							(					self							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     self.get_dummy_components()
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     AudioLDMPipeline(**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Any						    =     ["hey"]

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     audioldm_pipe(UpperCAmelCase_       ,			num_inference_steps=1   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     output.audios.shape
       assert audio_shape == (1, 256)

       SCREAMING_SNAKE_CASE							:   Tuple						    =     audioldm_pipe.vocoder.config
       config.model_in_dim *= 2
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     SpeechTaHifiGan(UpperCAmelCase_   ).to(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     audioldm_pipe(UpperCAmelCase_       ,			num_inference_steps=1   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     output.audios.shape
       # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
       assert audio_shape == (1, 256)


     def 					_A							(					self							:						Union[str, Any]   ):
       self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCAmelCase_   )


     def 					_A							(					self							:						Any   ):
       self._test_inference_batch_single_identical(test_mean_pixel_difference=UpperCAmelCase_   )






     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available()       ,			reason="XFormers attention is only available with CUDA and `xformers` installed"       ,			)
     def 					_A							(					self							:						int   ):
       self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCAmelCase_   )





@slow
class 			SCREAMING_SNAKE_CASE      (      unittest.TestCase       ):
     '''simple docstring'''


     def 					_A							(					self							:						Union[str, Any]   ):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()


     def 					_A							(					self							:						Dict       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						int="cpu"       ,			UpperCAmelCase_							:						Optional[int]=torch.floataa       ,			UpperCAmelCase_							:						Optional[Any]=0   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     torch.Generator(device=UpperCAmelCase_   ).manual_seed(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     np.random.RandomState(UpperCAmelCase_   ).standard_normal((1, 8, 128, 16)   )
       SCREAMING_SNAKE_CASE							:   List[str]						    =     torch.from_numpy(UpperCAmelCase_   ).to(device=UpperCAmelCase_       ,			dtype=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     {
           "prompt": "A hammer hitting a wooden surface",
           "latents": latents,
           "generator": generator,
           "num_inference_steps": 3,
           "guidance_scale": 2.5,
       }
       return inputs


     def 					_A							(					self							:						str   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     AudioLDMPipeline.from_pretrained("cvssp/audioldm"   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   Tuple						    =     self.get_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     25
       SCREAMING_SNAKE_CASE							:   Dict						    =     audioldm_pipe(**UpperCAmelCase_   ).audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) == 8_1920

       SCREAMING_SNAKE_CASE							:   str						    =     audio[7_7230:7_7240]
       SCREAMING_SNAKE_CASE							:   Dict						    =     np.array(
           [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315]   )
       SCREAMING_SNAKE_CASE							:   int						    =     np.abs(expected_slice - audio_slice   ).max()
       assert max_diff < 1E-2






     def 					_A							(					self							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   str						    =     AudioLDMPipeline.from_pretrained("cvssp/audioldm"   )
       SCREAMING_SNAKE_CASE							:   Any						    =     LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config   )
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     audioldm_pipe.to(UpperCAmelCase_   )
       audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     self.get_inputs(UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   str						    =     audioldm_pipe(**UpperCAmelCase_   ).audios[0]

       assert audio.ndim == 1
       assert len(UpperCAmelCase_   ) == 8_1920

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     audio[2_7780:2_7790]
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212]   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     np.abs(expected_slice - audio_slice   ).max()
       assert max_diff < 3E-2











'''simple docstring'''





def lowerCAmelCase    (__A):



     """simple docstring"""



     return credit_card_number.startswith(('''34''', '''35''', '''37''', '''4''', '''5''', '''6'''))




def lowerCAmelCase    (__A):



     """simple docstring"""



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

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

     return total % 10 == 0




def lowerCAmelCase    (__A):



     """simple docstring"""



     _a           =    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(__A) <= 16:
          print(F'''{error_message} of its length.''')
          return False

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

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



