


"""simple docstring"""



def     __lowerCAmelCase		(		lowercase    :    str					)      ->		bool:


    """simple docstring"""





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







def     __lowerCAmelCase		(		lowercase    :    str					)      ->		bool:


    """simple docstring"""





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

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

    return total % 10 == 0







def     __lowerCAmelCase		(		lowercase    :    str					)      ->		bool:


    """simple docstring"""





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

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

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









"""simple docstring"""



from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
  from ...onnx.config import PatchingSpec
  from ...tokenization_utils_base import PreTrainedTokenizerBase


__snake_case       =       logging.get_logger(__name__)

__snake_case       =       {
    """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json""",
    """allenai/longformer-large-4096""": """https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json""",
    """allenai/longformer-large-4096-finetuned-triviaqa""": (
        """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json"""
    ),
    """allenai/longformer-base-4096-extra.pos.embd.only""": (
        """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json"""
    ),
    """allenai/longformer-large-4096-extra.pos.embd.only""": (
        """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json"""
    ),
}







class _lowerCAmelCase							( snake_case_      ):
   __UpperCAmelCase					:			Tuple				    =    '''longformer'''







   def __init__(      self		,      UpperCamelCase__ = 512		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 1		,      UpperCamelCase__ = 0		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 3_0522		,      UpperCamelCase__ = 768		,      UpperCamelCase__ = 12		,      UpperCamelCase__ = 12		,      UpperCamelCase__ = 3072		,      UpperCamelCase__ = "gelu"		,      UpperCamelCase__ = 0.1		,      UpperCamelCase__ = 0.1		,      UpperCamelCase__ = 512		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 0.02		,      UpperCamelCase__ = 1e-12		,      UpperCamelCase__ = False		,      **UpperCamelCase__		,      )      ->						str:

       '''simple docstring'''




       super().__init__(pad_token_id=UpperCamelCase__		,      **UpperCamelCase__		)

       snake_case       : int    =       attention_window
       snake_case       : Any    =       sep_token_id
       snake_case       : Dict    =       bos_token_id
       snake_case       : int    =       eos_token_id
       snake_case       : List[str]    =       vocab_size
       snake_case       : Dict    =       hidden_size
       snake_case       : Optional[int]    =       num_hidden_layers
       snake_case       : List[str]    =       num_attention_heads
       snake_case       : Dict    =       hidden_act
       snake_case       : Union[str, Any]    =       intermediate_size
       snake_case       : Optional[int]    =       hidden_dropout_prob
       snake_case       : List[Any]    =       attention_probs_dropout_prob
       snake_case       : Any    =       max_position_embeddings
       snake_case       : Union[str, Any]    =       type_vocab_size
       snake_case       : Union[str, Any]    =       initializer_range
       snake_case       : int    =       layer_norm_eps
       snake_case       : str    =       onnx_export







class _lowerCAmelCase							( snake_case_      ):







   def __init__(      self		,      UpperCamelCase__		,      UpperCamelCase__ = "default"		,      UpperCamelCase__ = None		)      ->						List[str]:

       '''simple docstring'''




       super().__init__(UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)
       snake_case       : int    =       True







   @property
   def 					lowerCamelCase						(      self		)      ->						Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       if self.task == "multiple-choice":
           snake_case       : str    =       {0: "batch", 1: "choice", 2: "sequence"}
       else:
           snake_case       : List[str]    =       {0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
               ("global_attention_mask", dynamic_axis),
           ]		)







   @property
   def 					lowerCamelCase						(      self		)      ->						Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       snake_case       : str    =       super().outputs
       if self.task == "default":
           snake_case       : str    =       {0: "batch"}
       return outputs







   @property
   def 					lowerCamelCase						(      self		)      ->						float:

       '''simple docstring'''




       return 1e-4







   @property
   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       return max(super().default_onnx_opset		,      14		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__ = -1		,      UpperCamelCase__ = -1		,      UpperCamelCase__ = False		,      UpperCamelCase__ = None		,      )      ->						Mapping[str, Any]:

       '''simple docstring'''




       snake_case       : Optional[int]    =       super().generate_dummy_inputs(
           preprocessor=UpperCamelCase__		,      batch_size=UpperCamelCase__		,      seq_length=UpperCamelCase__		,      is_pair=UpperCamelCase__		,      framework=UpperCamelCase__		)
       import torch

       # for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
       # makes the export fail randomly
       snake_case       : Any    =       torch.zeros_like(inputs["input_ids"]		)
       # make every second token global
       snake_case       : Any    =       1

       return inputs





