





import argparse
import struct
import unittest





class 				A_				:







       """simple docstring"""





       def __init__(    self	:	Union[str, Any]						,__A	:	bytes  )						->					None:
         _lowercase							= data

         # Initialize hash values
         _lowercase							= [
             0x6A09E667,
             0xBB67AE85,
             0x3C6EF372,
             0xA54FF53A,
             0x510E527F,
             0x9B05688C,
             0x1F83D9AB,
             0x5BE0CD19,
         ]

         # Initialize round constants
         _lowercase							= [
             0x428A2F98,
             0x71374491,
             0xB5C0FBCF,
             0xE9B5DBA5,
             0x3956C25B,
             0x59F111F1,
             0x923F82A4,
             0xAB1C5ED5,
             0xD807AA98,
             0x12835B01,
             0x243185BE,
             0x550C7DC3,
             0x72BE5D74,
             0x80DEB1FE,
             0x9BDC06A7,
             0xC19BF174,
             0xE49B69C1,
             0xEFBE4786,
             0x0FC19DC6,
             0x240CA1CC,
             0x2DE92C6F,
             0x4A7484AA,
             0x5CB0A9DC,
             0x76F988DA,
             0x983E5152,
             0xA831C66D,
             0xB00327C8,
             0xBF597FC7,
             0xC6E00BF3,
             0xD5A79147,
             0x06CA6351,
             0x14292967,
             0x27B70A85,
             0x2E1B2138,
             0x4D2C6DFC,
             0x53380D13,
             0x650A7354,
             0x766A0ABB,
             0x81C2C92E,
             0x92722C85,
             0xA2BFE8A1,
             0xA81A664B,
             0xC24B8B70,
             0xC76C51A3,
             0xD192E819,
             0xD6990624,
             0xF40E3585,
             0x106AA070,
             0x19A4C116,
             0x1E376C08,
             0x2748774C,
             0x34B0BCB5,
             0x391C0CB3,
             0x4ED8AA4A,
             0x5B9CCA4F,
             0x682E6FF3,
             0x748F82EE,
             0x78A5636F,
             0x84C87814,
             0x8CC70208,
             0x90BEFFFA,
             0xA4506CEB,
             0xBEF9A3F7,
             0xC67178F2,
         ]

         _lowercase							= self.preprocessing(self.data  )
         self.final_hash()







       @staticmethod
       def    __UpperCAmelCase (    __A	:	bytes  )						->					bytes:
         _lowercase							= B'\x80' + (B'\x00' * (63 - (len(__A  ) + 8) % 64))
         _lowercase							= struct.pack('>Q'						,(len(__A  ) * 8)  )
         return data + padding + big_endian_integer







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					None:
         # Convert into blocks of 64 bytes
         _lowercase							= [
             self.preprocessed_data[x : x + 64]
             for x in range(0						,len(self.preprocessed_data  )						,64  )
         ]

         for block in self.blocks:
           # Convert the given block into a list of 4 byte integers
           _lowercase							= list(struct.unpack('>16L'						,__A  )  )
           # add 48 0-ed integers
           words += [0] * 48

           _lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= self.hashes

           for index in range(0						,64  ):
             if index > 15:
               # modify the zero-ed indexes at the end of the array
               _lowercase							= (
                   self.ror(words[index - 15]						,7  )
                   ^ self.ror(words[index - 15]						,18  )
                   ^ (words[index - 15] >> 3)
               )
               _lowercase							= (
                   self.ror(words[index - 2]						,17  )
                   ^ self.ror(words[index - 2]						,19  )
                   ^ (words[index - 2] >> 10)
               )

               _lowercase							= (
                   words[index - 16] + sa + words[index - 7] + sa
               ) % 0x100000000

             # Compression
             _lowercase							= self.ror(__A						,6  ) ^ self.ror(__A						,11  ) ^ self.ror(__A						,25  )
             _lowercase							= (e & f) ^ ((~e & 0xFFFFFFFF) & g)
             _lowercase							= (
                 h + sa + ch + self.round_constants[index] + words[index]
             ) % 0x100000000
             _lowercase							= self.ror(__A						,2  ) ^ self.ror(__A						,13  ) ^ self.ror(__A						,22  )
             _lowercase							= (a & b) ^ (a & c) ^ (b & c)
             _lowercase							= (sa + maj) % 0x100000000

             _lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= (
                 g,
                 f,
                 e,
                 ((d + tempa) % 0x100000000),
                 c,
                 b,
                 a,
                 ((tempa + tempa) % 0x100000000),
             )

           _lowercase							= [a, b, c, d, e, f, g, h]

           # Modify final values
           _lowercase							= [
               ((element + mutated_hash_values[index]) % 0x100000000)
               for index, element in enumerate(self.hashes  )
           ]

         _lowercase							= ''.join([hex(__A  )[2:].zfill(8  ) for value in self.hashes]  )







       def    __UpperCAmelCase (    self	:	int						,__A	:	int						,__A	:	int  )						->					int:
         return 0xFFFFFFFF & (value << (32 - rotations)) | (value >> rotations)





class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       def    __UpperCAmelCase (    self	:	List[str]  )						->					None:
         import hashlib

         _lowercase							= bytes('Test String'						,'utf-8'  )
         self.assertEqual(SHAaaa(__A  ).hash						,hashlib.shaaaa(__A  ).hexdigest()  )

def  SCREAMING_SNAKE_CASE__       (  )      ->						None:
  import doctest

  doctest.testmod()

  _lowercase							= argparse.ArgumentParser()
  parser.add_argument(
      '-s'			,							'--string'			,							dest='input_string'			,							default='Hello World!! Welcome to Cryptography'			,							help='Hash the string'			,							)
  parser.add_argument(
      '-f'			,							'--file'			,							dest='input_file'			,							help='Hash contents of a file'     )

  _lowercase							= parser.parse_args()

  _lowercase							= args.input_string

  # hash input should be a bytestring
  if args.input_file:
    with open(args.input_file			,							'rb'     ) as f:
      _lowercase							= f.read()
  else:
    _lowercase							= bytes(snake_case__			,							'utf-8'     )

  print(SHAaaa(snake_case__     ).hash     )


if __name__ == "__main__":
      main()






import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


snake_case 				=       get_tests_dir("""fixtures/test_sentencepiece_no_bos.model""")





@require_sentencepiece
@require_tokenizers
class 				A_				(      UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizer
       SCREAMING_SNAKE_CASE_      : Optional[int]      =  PegasusTokenizerFast
       SCREAMING_SNAKE_CASE_      : Any      =  True
       SCREAMING_SNAKE_CASE_      : Optional[int]      =  True







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Any:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _lowercase							= PegasusTokenizer(__A  )
         tokenizer.save_pretrained(self.tmpdirname  )







       @cached_property
       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					List[Any]:
         return PegasusTokenizer.from_pretrained('google/pegasus-large'  )







       def    __UpperCAmelCase (    self	:	Any						,**__A	:	int  )						->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname						,**__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,__A	:	int  )						->					List[str]:
         return ("This is a test", "This is a test")







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[Any]:
         _lowercase							= '</s>'
         _lowercase							= 1

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__A  )						,__A  )
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__A  )						,__A  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Optional[Any]:
         _lowercase							= list(self.get_tokenizer().get_vocab().keys()  )

         self.assertEqual(vocab_keys[0]						,'<pad>'  )
         self.assertEqual(vocab_keys[1]						,'</s>'  )
         self.assertEqual(vocab_keys[-1]						,'v'  )
         self.assertEqual(len(__A  )						,1103  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         self.assertEqual(self.get_tokenizer().vocab_size						,1103  )







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					List[str]:
         _lowercase							= self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= self.tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= (
             'Let\'s see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important'
             ' </s> <pad> <pad> <pad>'
         )
         _lowercase							= rust_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         _lowercase							= py_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					List[Any]:
         _lowercase							= self._large_tokenizer
         # <mask_1> masks whole sentence while <mask_2> masks single word
         _lowercase							= '<mask_1> To ensure a <mask_2> flow of bank resolutions.'
         _lowercase							= [2, 413, 615, 114, 3, 1971, 113, 1679, 1_0710, 107, 1]
         _lowercase							= tokenizer([raw_input_str]						,return_tensors=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       def    __UpperCAmelCase (    self	:	int  )						->					Union[str, Any]:
         _lowercase							= self._large_tokenizer
         # The tracebacks for the following asserts are **better** without messages or self.assertEqual
         assert tokenizer.vocab_size == 9_6103
         assert tokenizer.pad_token_id == 0
         assert tokenizer.eos_token_id == 1
         assert tokenizer.offset == 103
         assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
         assert tokenizer.unk_token == "<unk>"
         assert tokenizer.model_max_length == 1024
         _lowercase							= 'To ensure a smooth flow of bank resolutions.'
         _lowercase							= [413, 615, 114, 2291, 1971, 113, 1679, 1_0710, 107, 1]
         _lowercase							= tokenizer([raw_input_str]						,return_tensors=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )
         assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]  ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]







       @require_torch
       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					List[str]:
         _lowercase							= ['This is going to be way too long.' * 150, 'short example']
         _lowercase							= ['not super long but more than 5 tokens', 'tiny']
         _lowercase							= self._large_tokenizer(__A						,padding=__A						,truncation=__A						,return_tensors='pt'  )
         _lowercase							= self._large_tokenizer(
             text_target=__A						,max_length=5						,padding=__A						,truncation=__A						,return_tensors='pt'  )

         assert batch.input_ids.shape == (2, 1024)
         assert batch.attention_mask.shape == (2, 1024)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__A  ) == 2  # input_ids, attention_mask.







       @slow
       def    __UpperCAmelCase (    self	:	Dict  )						->					Optional[int]:
         # fmt: off
         _lowercase							= {'input_ids': [[3_8979, 143, 1_8485, 606, 130, 2_6669, 8_7686, 121, 5_4189, 1129, 111, 2_6669, 8_7686, 121, 9114, 1_4787, 121, 1_3249, 158, 592, 956, 121, 1_4621, 3_1576, 143, 6_2613, 108, 9688, 930, 4_3430, 1_1562, 6_2613, 304, 108, 1_1443, 897, 108, 9314, 1_7415, 6_3399, 108, 1_1443, 7614, 1_8316, 118, 4284, 7148, 1_2430, 143, 1400, 2_5703, 158, 111, 4284, 7148, 1_1772, 143, 2_1297, 1064, 158, 122, 204, 3506, 1754, 1133, 1_4787, 1581, 115, 3_3224, 4482, 111, 1355, 110, 2_9173, 317, 5_0833, 108, 2_0147, 9_4665, 111, 7_7198, 107, 1], [110, 6_2613, 117, 638, 112, 1133, 121, 2_0098, 1355, 7_9050, 1_3872, 135, 1596, 5_3541, 1352, 141, 1_3039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 1_8289, 1_7780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__A						,model_name='google/bigbird-pegasus-large-arxiv'						,revision='ba85d0851d708441f91440d509690f1ab6353415'						,)





@require_sentencepiece
@require_tokenizers
class 				A_				(      UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizer
       SCREAMING_SNAKE_CASE_      : int      =  PegasusTokenizerFast
       SCREAMING_SNAKE_CASE_      : str      =  True
       SCREAMING_SNAKE_CASE_      : List[Any]      =  True







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[int]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _lowercase							= PegasusTokenizer(__A						,offset=0						,mask_token_sent=__A						,mask_token='[MASK]'  )
         tokenizer.save_pretrained(self.tmpdirname  )







       @cached_property
       def    __UpperCAmelCase (    self	:	str  )						->					Optional[Any]:
         return PegasusTokenizer.from_pretrained('google/bigbird-pegasus-large-arxiv'  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,**__A	:	Union[str, Any]  )						->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname						,**__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]						,__A	:	int  )						->					Tuple:
         return ("This is a test", "This is a test")







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Dict:
         _lowercase							= self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= self.tokenizer_class.from_pretrained(self.tmpdirname  )
         _lowercase							= (
             'Let\'s see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>'
             ' <pad> <pad> <pad>'
         )
         _lowercase							= rust_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         _lowercase							= py_tokenizer([raw_input_str]						,return_tensors=__A						,add_special_tokens=__A  ).input_ids[0]
         self.assertListEqual(__A						,__A  )







       @require_torch
       def    __UpperCAmelCase (    self	:	List[str]  )						->					Dict:
         _lowercase							= ['This is going to be way too long.' * 1000, 'short example']
         _lowercase							= ['not super long but more than 5 tokens', 'tiny']
         _lowercase							= self._large_tokenizer(__A						,padding=__A						,truncation=__A						,return_tensors='pt'  )
         _lowercase							= self._large_tokenizer(
             text_target=__A						,max_length=5						,padding=__A						,truncation=__A						,return_tensors='pt'  )

         assert batch.input_ids.shape == (2, 4096)
         assert batch.attention_mask.shape == (2, 4096)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__A  ) == 2  # input_ids, attention_mask.







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					int:
         _lowercase							= (
             'This is an example string that is used to test the original TF implementation against the HF'
             ' implementation'
         )

         _lowercase							= self._large_tokenizer(__A  ).input_ids

         self.assertListEqual(
             __A						,[182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 2_5016, 3137, 464, 109, 2_6955, 3137, 1]						,)