






"""simple docstring"""







def 						lowercase__(A						)				->int:




						"""simple docstring"""



						barcode //= 10  # exclude the last digit
						lowercase__				:      Union[str, Any]=       False
						lowercase__				:      Union[str, Any]=       0

						# extract and check each digit
						while barcode != 0:
												lowercase__				:      Dict=       1 if checker else 3
												s += mult * (barcode % 10)
												barcode //= 10
												lowercase__				:      Tuple=       not checker

						return (10 - (s % 10)) % 10





def 						lowercase__(A						)				->bool:




						"""simple docstring"""



						return len(str(A						)						) == 13 and get_check_digit(A						) == barcode % 10





def 						lowercase__(A						)				->int:




						"""simple docstring"""



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


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			a :				int      					=		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.""")














"""simple docstring"""







import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
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.models.speech_to_text_a.modeling_speech_to_text_a import (
			    SpeechaTextaDecoder,
			    SpeechaTextaForCausalLM,
			)


@require_torch
class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__=99       ,  snake_case__=13       ,  snake_case__=16       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=False       ,  snake_case__=True       ,  snake_case__=2       ,  snake_case__=32       ,  snake_case__=4       ,  snake_case__=4       ,  snake_case__=30       ,  snake_case__=0       ,  snake_case__=1       ,  snake_case__=2       ,  snake_case__=None       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       parent
												lowercase__				:      Dict=       batch_size
												lowercase__				:      List[str]=       decoder_seq_length
												# For common tests
												lowercase__				:      List[str]=       self.decoder_seq_length
												lowercase__				:      int=       is_training
												lowercase__				:      Any=       use_attention_mask
												lowercase__				:      List[str]=       use_labels

												lowercase__				:      Dict=       vocab_size
												lowercase__				:      Dict=       d_model
												lowercase__				:      Union[str, Any]=       d_model
												lowercase__				:      List[str]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_ffn_dim
												lowercase__				:      Union[str, Any]=       decoder_attention_heads
												lowercase__				:      Tuple=       decoder_attention_heads
												lowercase__				:      Optional[Any]=       eos_token_id
												lowercase__				:      List[Any]=       bos_token_id
												lowercase__				:      Any=       pad_token_id
												lowercase__				:      Union[str, Any]=       decoder_start_token_id
												lowercase__				:      Optional[Any]=       use_cache
												lowercase__				:      List[Any]=       max_position_embeddings

												lowercase__				:      Tuple=       None
												lowercase__				:      Optional[Any]=       decoder_seq_length
												lowercase__				:      Optional[int]=       2
												lowercase__				:      Tuple=       1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Tuple=       None
												if self.use_attention_mask:
																		lowercase__				:      List[str]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  vocab_size=2			)

												lowercase__				:      Any=       None
												if self.use_labels:
																		lowercase__				:      str=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Dict=       SpeechaTextaConfig(
												    vocab_size=self.vocab_size       ,  d_model=self.d_model       ,  decoder_layers=self.decoder_layers       ,  decoder_ffn_dim=self.decoder_ffn_dim       ,  decoder_attention_heads=self.decoder_attention_heads       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.bos_token_id       ,  use_cache=self.use_cache       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  max_position_embeddings=self.max_position_embeddings       ,  )

												return (
												    config,
												    input_ids,
												    attention_mask,
												    lm_labels,
												)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       True
												lowercase__				:      List[Any]=       SpeechaTextaDecoder(config=snake_case__			).to(snake_case__			).eval()
												lowercase__				:      Any=       input_ids[:2]

												input_ids[input_ids == 0] += 1
												# first forward pass
												lowercase__				:      List[str]=       model(snake_case__       ,  use_cache=snake_case__			)
												lowercase__				:      Optional[Any]=       model(snake_case__			)
												lowercase__				:      List[Any]=       model(snake_case__       ,  use_cache=snake_case__			)

												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			)			)
												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			) + 1			)

												lowercase__				:      List[Any]=       outputs["past_key_values"]

												# create hypothetical next token and extent to next_input_ids
												lowercase__				:      List[Any]=       ids_tensor((2, 1)       ,  config.vocab_size - 1			) + 1

												# append to next input_ids and
												lowercase__				:      Tuple=       torch.cat([input_ids, next_tokens]       ,  dim=-1			)

												print(snake_case__			)

												lowercase__				:      int=       model(snake_case__			)["last_hidden_state"]
												lowercase__				:      int=       model(snake_case__       ,  past_key_values=snake_case__			)["last_hidden_state"]

												# select random slice
												lowercase__				:      str=       ids_tensor((1,)       ,  output_from_past.shape[-1]			).item()
												lowercase__				:      Any=       output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
												lowercase__				:      int=       output_from_past[:, 0, random_slice_idx].detach()

												# test that outputs are equal for slice
												assert torch.allclose(snake_case__       ,  snake_case__       ,  atol=1e-3			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      str=       self.prepare_config_and_inputs()
												(
												    (
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	
												)				:      Dict=       config_and_inputs

												lowercase__				:      Optional[int]=       {
												    "input_ids": input_ids,
												    "attention_mask": attention_mask,
												}
												return config, inputs_dict


@require_torch
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
						__lowerCamelCase				       =					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
						__lowerCamelCase				       =					{"text-generation": SpeechaTextaForCausalLM} if is_torch_available() else {}
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					False




						def 		UpperCAmelCase_       (   self       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       SpeechaTextaStandaloneDecoderModelTester(self       ,  is_training=snake_case__			)
												lowercase__				:      int=       ConfigTester(self       ,  config_class=snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.config_tester.run_common_tests()




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_decoder_model_past(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												return






