





import unittest

from transformers import FunnelConfig, FunnelTokenizer, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         MODEL_FOR_PRETRAINING_MAPPING,
         FunnelBaseModel,
         FunnelForMaskedLM,
         FunnelForMultipleChoice,
         FunnelForPreTraining,
         FunnelForQuestionAnswering,
         FunnelForSequenceClassification,
         FunnelForTokenClassification,
         FunnelModel,
     )







class        __lowerCAmelCase :







      def __init__(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=1_3	,   lowerCAmelCase__=7	,   lowerCAmelCase__=True	,   lowerCAmelCase__=True	,   lowerCAmelCase__=True	,   lowerCAmelCase__=True	,   lowerCAmelCase__=9_9	,   lowerCAmelCase__=[1, 1, 2]	,   lowerCAmelCase__=1	,   lowerCAmelCase__=3_2	,   lowerCAmelCase__=4	,   lowerCAmelCase__=8	,   lowerCAmelCase__=3_7	,   lowerCAmelCase__="gelu_new"	,   lowerCAmelCase__=0.1	,   lowerCAmelCase__=0.1	,   lowerCAmelCase__=0.0	,   lowerCAmelCase__=5_1_2	,   lowerCAmelCase__=3	,   lowerCAmelCase__=0.02	,   lowerCAmelCase__=3	,   lowerCAmelCase__=4	,   lowerCAmelCase__=None	,   lowerCAmelCase__=False	,   )     ->		Any:



        '''simple docstring'''




        a__			:      Tuple            =parent
        a__			:      Dict            =batch_size
        a__			:      Dict            =seq_length
        a__			:      str            =is_training
        a__			:      List[str]            =use_input_mask
        a__			:      Union[str, Any]            =use_token_type_ids
        a__			:      List[Any]            =use_labels
        a__			:      Optional[Any]            =vocab_size
        a__			:      Union[str, Any]            =block_sizes
        a__			:      Any            =num_decoder_layers
        a__			:      Any            =d_model
        a__			:      Optional[int]            =n_head
        a__			:      List[str]            =d_head
        a__			:      Optional[int]            =d_inner
        a__			:      Optional[Any]            =hidden_act
        a__			:      Optional[int]            =hidden_dropout
        a__			:      str            =attention_dropout
        a__			:      Dict            =activation_dropout
        a__			:      Optional[Any]            =max_position_embeddings
        a__			:      Dict            =type_vocab_size
        a__			:      Any            =2
        a__			:      List[str]            =num_labels
        a__			:      int            =num_choices
        a__			:      Dict            =scope
        a__			:      int            =initializer_std

        # Used in the tests to check the size of the first attention layer
        a__			:      Dict            =n_head
        # Used in the tests to check the size of the first hidden state
        a__			:      Dict            =self.d_model
        # Used in the tests to check the number of output hidden states/attentions
        a__			:      Optional[int]            =sum(self.block_sizes							) + (0 if base else self.num_decoder_layers)
        # FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
        # the last hidden state of the first block (which is the first hidden state of the decoder).
        if not base:
          a__			:      Tuple            =self.num_hidden_layers + 2







      def      _lowercase						(					self							)     ->		Optional[int]:



        '''simple docstring'''




        a__			:      List[str]            =ids_tensor([self.batch_size, self.seq_length]	,   self.vocab_size							)

        a__			:      Optional[int]            =None
        if self.use_input_mask:
          a__			:      Optional[Any]            =ids_tensor([self.batch_size, self.seq_length]	,   vocab_size=2							)

        a__			:      Any            =None
        if self.use_token_type_ids:
          a__			:      Optional[int]            =ids_tensor([self.batch_size, self.seq_length]	,   self.type_vocab_size							)

        a__			:      Tuple            =None
        a__			:      Any            =None
        a__			:      Any            =None
        if self.use_labels:
          a__			:      Dict            =ids_tensor([self.batch_size]	,   self.type_sequence_label_size							)
          a__			:      Any            =ids_tensor([self.batch_size, self.seq_length]	,   self.num_labels							)
          a__			:      Union[str, Any]            =ids_tensor([self.batch_size]	,   self.num_choices							)
          a__			:      Optional[Any]            =ids_tensor([self.batch_size, self.seq_length]	,   1							)

        a__			:      Tuple            =self.get_config()

        return (
            config,
            input_ids,
            token_type_ids,
            input_mask,
            sequence_labels,
            token_labels,
            choice_labels,
            fake_token_labels,
        )







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



        '''simple docstring'''




        return FunnelConfig(
            vocab_size=self.vocab_size	,   block_sizes=self.block_sizes	,   num_decoder_layers=self.num_decoder_layers	,   d_model=self.d_model	,   n_head=self.n_head	,   d_head=self.d_head	,   d_inner=self.d_inner	,   hidden_act=self.hidden_act	,   hidden_dropout=self.hidden_dropout	,   attention_dropout=self.attention_dropout	,   activation_dropout=self.activation_dropout	,   max_position_embeddings=self.max_position_embeddings	,   type_vocab_size=self.type_vocab_size	,   initializer_std=self.initializer_std	,   )







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Optional[int]:



        '''simple docstring'''




        a__			:      Optional[Any]            =FunnelModel(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      Optional[Any]            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)
        a__			:      Optional[Any]            =model(lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)
        a__			:      Union[str, Any]            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)							)

        a__			:      List[Any]            =False
        a__			:      Any            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)							)

        a__			:      Dict            =False
        a__			:      Any            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		str:



        '''simple docstring'''




        a__			:      int            =FunnelBaseModel(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      List[str]            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)
        a__			:      Union[str, Any]            =model(lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)
        a__			:      Union[str, Any]            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 2, self.d_model)							)

        a__			:      List[Any]            =False
        a__			:      Optional[int]            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 3, self.d_model)							)

        a__			:      Optional[int]            =False
        a__			:      str            =model(lowerCAmelCase__							)
        self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 2, self.d_model)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Optional[int]:



        '''simple docstring'''




        a__			:      Union[str, Any]            =self.num_labels
        a__			:      Optional[Any]            =FunnelForPreTraining(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      Union[str, Any]            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Tuple:



        '''simple docstring'''




        a__			:      Optional[Any]            =FunnelForMaskedLM(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      Tuple            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.vocab_size)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Dict:



        '''simple docstring'''




        a__			:      Any            =self.num_labels
        a__			:      Any            =FunnelForSequenceClassification(lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      List[str]            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Optional[Any]:



        '''simple docstring'''




        a__			:      List[str]            =self.num_choices
        a__			:      int            =FunnelForMultipleChoice(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      Optional[Any]            =input_ids.unsqueeze(1							).expand(-1	,   self.num_choices	,   -1							).contiguous()
        a__			:      Optional[Any]            =token_type_ids.unsqueeze(1							).expand(-1	,   self.num_choices	,   -1							).contiguous()
        a__			:      Optional[Any]            =input_mask.unsqueeze(1							).expand(-1	,   self.num_choices	,   -1							).contiguous()
        a__			:      Union[str, Any]            =model(
            lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   labels=lowerCAmelCase__	,   )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_choices)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		Tuple:



        '''simple docstring'''




        a__			:      str            =self.num_labels
        a__			:      List[str]            =FunnelForTokenClassification(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      Any            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   labels=lowerCAmelCase__							)
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.num_labels)							)







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   )     ->		str:



        '''simple docstring'''




        a__			:      int            =FunnelForQuestionAnswering(config=lowerCAmelCase__							)
        model.to(lowerCAmelCase__							)
        model.eval()
        a__			:      str            =model(
            lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__	,   start_positions=lowerCAmelCase__	,   end_positions=lowerCAmelCase__	,   )
        self.parent.assertEqual(result.start_logits.shape	,   (self.batch_size, self.seq_length)							)
        self.parent.assertEqual(result.end_logits.shape	,   (self.batch_size, self.seq_length)							)







      def      _lowercase						(					self							)     ->		Optional[int]:



        '''simple docstring'''




        a__			:      Union[str, Any]            =self.prepare_config_and_inputs()
        (
            (
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							(
            a__
        )      ,							
        )			:      List[str]            =config_and_inputs
        a__			:      int            ={"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
        return config, inputs_dict







@require_torch
class        __lowerCAmelCase (					UpperCamelCase__		,       UpperCamelCase__		,       unittest.TestCase):
      _lowercase       :      Optional[Any]        =    False
      _lowercase       :      int        =    False
      _lowercase       :      Optional[int]        =    (
          (
              FunnelModel,
              FunnelForMaskedLM,
              FunnelForPreTraining,
              FunnelForQuestionAnswering,
              FunnelForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      _lowercase       :      List[str]        =    (
          {
              """feature-extraction""": (FunnelBaseModel, FunnelModel),
              """fill-mask""": FunnelForMaskedLM,
              """question-answering""": FunnelForQuestionAnswering,
              """text-classification""": FunnelForSequenceClassification,
              """token-classification""": FunnelForTokenClassification,
              """zero-shot""": FunnelForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__=False							)     ->		List[str]:



        '''simple docstring'''




        a__			:      List[str]            =super()._prepare_for_class(lowerCAmelCase__	,   lowerCAmelCase__	,   return_labels=lowerCAmelCase__							)

        if return_labels:
          if model_class in get_values(lowerCAmelCase__							):
            a__			:      List[str]            =torch.zeros(
                (self.model_tester.batch_size, self.model_tester.seq_length)	,   dtype=torch.long	,   device=lowerCAmelCase__							)
        return inputs_dict







      def      _lowercase						(					self							)     ->		List[str]:



        '''simple docstring'''




        a__			:      List[Any]            =FunnelModelTester(self							)
        a__			:      Optional[int]            =ConfigTester(self	,   config_class=lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		List[str]:



        '''simple docstring'''




        self.config_tester.run_common_tests()







      def      _lowercase						(					self							)     ->		Optional[int]:



        '''simple docstring'''




        a__			:      Optional[int]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		List[str]:



        '''simple docstring'''




        a__			:      Union[str, Any]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		Optional[int]:



        '''simple docstring'''




        a__			:      Optional[int]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		List[Any]:



        '''simple docstring'''




        a__			:      int            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		Tuple:



        '''simple docstring'''




        a__			:      List[str]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__							)







      def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Optional[Any]:



        '''simple docstring'''




        if hasattr(lowerCAmelCase__	,   "weight"							) and module.weight is not None:
          module.weight.data.fill_(3							)
        if hasattr(lowerCAmelCase__	,   "bias"							) and module.bias is not None:
          module.bias.data.fill_(3							)

        for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
          if hasattr(lowerCAmelCase__	,   lowerCAmelCase__							) and getattr(lowerCAmelCase__	,   lowerCAmelCase__							) is not None:
            a__			:      int            =getattr(lowerCAmelCase__	,   lowerCAmelCase__							)
            weight.data.fill_(3							)







@require_torch
class        __lowerCAmelCase (					UpperCamelCase__		,       unittest.TestCase):
      _lowercase       :      Tuple        =    False
      _lowercase       :      List[str]        =    False
      _lowercase       :      str        =    (
          (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
      )







      def      _lowercase						(					self							)     ->		List[Any]:



        '''simple docstring'''




        a__			:      Union[str, Any]            =FunnelModelTester(self	,   base=lowerCAmelCase__							)
        a__			:      List[Any]            =ConfigTester(self	,   config_class=lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		List[str]:



        '''simple docstring'''




        self.config_tester.run_common_tests()







      def      _lowercase						(					self							)     ->		Tuple:



        '''simple docstring'''




        a__			:      Dict            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_base_model(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		Any:



        '''simple docstring'''




        a__			:      Optional[int]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		int:



        '''simple docstring'''




        a__			:      Optional[Any]            =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase__							)







      def      _lowercase						(					self							)     ->		int:



        '''simple docstring'''




        a__      ,							a__			:      Any            =self.model_tester.prepare_config_and_inputs_for_common()
        a__			:      List[Any]            =True

        for model_class in self.all_model_classes:
          if model_class.__name__ == "FunnelBaseModel":
            continue
          a__			:      Any            =model_class(lowerCAmelCase__							)
          model.to(lowerCAmelCase__							)
          model.train()
          a__			:      Union[str, Any]            =self._prepare_for_class(lowerCAmelCase__	,   lowerCAmelCase__	,   return_labels=lowerCAmelCase__							)
          a__			:      Tuple            =model(**lowerCAmelCase__							).loss
          loss.backward()







      def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		str:



        '''simple docstring'''




        if hasattr(lowerCAmelCase__	,   "weight"							) and module.weight is not None:
          module.weight.data.fill_(3							)
        if hasattr(lowerCAmelCase__	,   "bias"							) and module.bias is not None:
          module.bias.data.fill_(3							)

        for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
          if hasattr(lowerCAmelCase__	,   lowerCAmelCase__							) and getattr(lowerCAmelCase__	,   lowerCAmelCase__							) is not None:
            a__			:      List[Any]            =getattr(lowerCAmelCase__	,   lowerCAmelCase__							)
            weight.data.fill_(3							)







@require_torch
@require_sentencepiece
@require_tokenizers
class        __lowerCAmelCase (					unittest.TestCase):







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



        '''simple docstring'''




        a__			:      Tuple            =1_3
        a__			:      List[Any]            =7
        a__			:      List[Any]            =torch.arange(0	,   batch_size * sequence_length							).long().reshape(lowerCAmelCase__	,   lowerCAmelCase__							)
        a__			:      Tuple            =[0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
        a__			:      Optional[Any]            =torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]							)

        a__			:      Any            =FunnelModel.from_pretrained("sgugger/funnel-random-tiny"							)
        a__			:      Any            =model(lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)[0].abs()

        a__			:      Tuple            =torch.tensor(23_44.83_52							)
        a__			:      List[str]            =torch.tensor(0.80_52							)
        self.assertTrue(torch.allclose(output.sum()	,   lowerCAmelCase__	,   atol=1E-4							)							)
        self.assertTrue(torch.allclose(output.mean()	,   lowerCAmelCase__	,   atol=1E-4							)							)

        a__			:      Any            =torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]							)
        a__			:      Tuple            =model(lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   token_type_ids=lowerCAmelCase__							)[0].abs()

        a__			:      Union[str, Any]            =torch.tensor(23_43.84_25							)
        a__			:      List[Any]            =torch.tensor(0.80_49							)
        self.assertTrue(torch.allclose(output.sum()	,   lowerCAmelCase__	,   atol=1E-4							)							)
        self.assertTrue(torch.allclose(output.mean()	,   lowerCAmelCase__	,   atol=1E-4							)							)







      @slow
      def      _lowercase						(					self							)     ->		str:



        '''simple docstring'''




        a__			:      List[Any]            =FunnelTokenizer.from_pretrained("huggingface/funnel-small"							)
        a__			:      Dict            =FunnelModel.from_pretrained("huggingface/funnel-small"							)
        a__			:      str            =tokenizer("Hello! I am the Funnel Transformer model."	,   return_tensors="pt"							)
        a__			:      Tuple            =model(**lowerCAmelCase__							)[0]

        a__			:      List[Any]            =torch.tensor(2_35.72_46							)
        a__			:      Tuple            =torch.tensor(0.02_56							)
        self.assertTrue(torch.allclose(output.sum()	,   lowerCAmelCase__	,   atol=1E-4							)							)
        self.assertTrue(torch.allclose(output.mean()	,   lowerCAmelCase__	,   atol=1E-4							)							)













def   _A (	SCREAMING_SNAKE_CASE  :     int		):





  """simple docstring"""



  barcode //= 10  # exclude the last digit
  a__			:      int            =False
  a__			:      List[str]            =0

  # extract and check each digit
  while barcode != 0:
    a__			:      Optional[Any]            =1 if checker else 3
    s += mult * (barcode % 10)
    barcode //= 10
    a__			:      Union[str, Any]            =not checker

  return (10 - (s % 10)) % 10
def   _A (	SCREAMING_SNAKE_CASE  :     int		):





  """simple docstring"""



  return len(str(SCREAMING_SNAKE_CASE		)		) == 13 and get_check_digit(SCREAMING_SNAKE_CASE		) == barcode % 10
def   _A (	SCREAMING_SNAKE_CASE  :     str		):





  """simple docstring"""



  if str(SCREAMING_SNAKE_CASE		).isalpha():
    a__			:      Tuple            =f'''Barcode \'{barcode}\' has alphabetic characters.'''
    raise ValueError(SCREAMING_SNAKE_CASE		)
  elif int(SCREAMING_SNAKE_CASE		) < 0:
    raise ValueError("The entered barcode has a negative value. Try again."		)
  else:
    return int(SCREAMING_SNAKE_CASE		)


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     UpperCAmelCase			:			List[str]	  = get_barcode(input("""Barcode: """).strip())

     if is_valid(barcode):
          print(F"""'{barcode}' is a valid barcode.""")
     else:
          print(F"""'{barcode}' is NOT a valid barcode.""")






