


import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
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				:    Any       				=     '''▁'''

snake_case				:    Optional[Any]       				=     get_tests_dir('''fixtures/test_sentencepiece.model''')







@require_sentencepiece
@require_tokenizers
class 		_snake_case  (      _snake_case						,    unittest.TestCase							):
 SCREAMING_SNAKE_CASE__      =       BigBirdTokenizer
 SCREAMING_SNAKE_CASE__      =       BigBirdTokenizerFast
 SCREAMING_SNAKE_CASE__      =       True
 SCREAMING_SNAKE_CASE__      =       True




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       super().setUp()

       a						:Union[str, Any] 							=       self.tokenizer_class(_lowerCamelCase					,  keep_accents=_lowerCamelCase    )
       tokenizer.save_pretrained(self.tmpdirname    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Dict 							=       '''<s>'''
       a						:int 							=       1

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




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:int 							=       list(self.get_tokenizer().get_vocab().keys()    )

       self.assertEqual(vocab_keys[0]					,  '''<unk>'''    )
       self.assertEqual(vocab_keys[1]					,  '''<s>'''    )
       self.assertEqual(vocab_keys[-1]					,  '''[MASK]'''    )
       self.assertEqual(len(_lowerCamelCase    )					,  1004    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       self.assertEqual(self.get_tokenizer().vocab_size					,  1000    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       if not self.test_rust_tokenizer:
             return

       a						:Union[str, Any] 							=       self.get_tokenizer()
       a						:Dict 							=       self.get_rust_tokenizer()

       a						:Union[str, Any] 							=       '''I was born in 92000, and this is falsé.'''

       a						:List[str] 							=       tokenizer.tokenize(_lowerCamelCase    )
       a						:Union[str, Any] 							=       rust_tokenizer.tokenize(_lowerCamelCase    )
       self.assertListEqual(_lowerCamelCase					,  _lowerCamelCase    )

       a						:List[Any] 							=       tokenizer.encode(_lowerCamelCase					,  add_special_tokens=_lowerCamelCase    )
       a						:str 							=       rust_tokenizer.encode(_lowerCamelCase					,  add_special_tokens=_lowerCamelCase    )
       self.assertListEqual(_lowerCamelCase					,  _lowerCamelCase    )

       a						:str 							=       self.get_rust_tokenizer()
       a						:Optional[Any] 							=       tokenizer.encode(_lowerCamelCase    )
       a						:Dict 							=       rust_tokenizer.encode(_lowerCamelCase    )
       self.assertListEqual(_lowerCamelCase					,  _lowerCamelCase    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:str 							=       BigBirdTokenizer(_lowerCamelCase					,  keep_accents=_lowerCamelCase    )

       a						:str 							=       tokenizer.tokenize('''This is a test'''    )
       self.assertListEqual(_lowerCamelCase					,  ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']    )

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(_lowerCamelCase    )					,  [285, 46, 10, 170, 382]					,  )

       a						:List[Any] 							=       tokenizer.tokenize('''I was born in 92000, and this is falsé.'''    )
       self.assertListEqual(
           _lowerCamelCase					,  [
               SPIECE_UNDERLINE + '''I''',
               SPIECE_UNDERLINE + '''was''',
               SPIECE_UNDERLINE + '''b''',
               '''or''',
               '''n''',
               SPIECE_UNDERLINE + '''in''',
               SPIECE_UNDERLINE + '''''',
               '''9''',
               '''2''',
               '''0''',
               '''0''',
               '''0''',
               ''',''',
               SPIECE_UNDERLINE + '''and''',
               SPIECE_UNDERLINE + '''this''',
               SPIECE_UNDERLINE + '''is''',
               SPIECE_UNDERLINE + '''f''',
               '''al''',
               '''s''',
               '''é''',
               '''.''',
           ]					,  )
       a						:List[Any] 							=       tokenizer.convert_tokens_to_ids(_lowerCamelCase    )
       self.assertListEqual(
           _lowerCamelCase					,  [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]					,  )

       a						:Union[str, Any] 							=       tokenizer.convert_ids_to_tokens(_lowerCamelCase    )
       self.assertListEqual(
           _lowerCamelCase					,  [
               SPIECE_UNDERLINE + '''I''',
               SPIECE_UNDERLINE + '''was''',
               SPIECE_UNDERLINE + '''b''',
               '''or''',
               '''n''',
               SPIECE_UNDERLINE + '''in''',
               SPIECE_UNDERLINE + '''''',
               '''<unk>''',
               '''2''',
               '''0''',
               '''0''',
               '''0''',
               ''',''',
               SPIECE_UNDERLINE + '''and''',
               SPIECE_UNDERLINE + '''this''',
               SPIECE_UNDERLINE + '''is''',
               SPIECE_UNDERLINE + '''f''',
               '''al''',
               '''s''',
               '''<unk>''',
               '''.''',
           ]					,  )




 @cached_property
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       return BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base'''    )




 @slow
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:int 							=       '''Hello World!'''
       a						:Optional[int] 							=       [65, 1_8536, 2260, 101, 66]

       self.assertListEqual(_lowerCamelCase					,  self.big_tokenizer.encode(_lowerCamelCase    )    )




 @slow
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Union[str, Any] 							=       (
           '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
           ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
       )
       # fmt: off
       a						:str 							=       [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 3_4324, 497, 391, 408, 1_1342, 1244, 385, 100, 938, 985, 456, 574, 362, 1_2597, 3200, 3129, 1172, 66]  # noqa: E231
       # fmt: on
       self.assertListEqual(_lowerCamelCase					,  self.big_tokenizer.encode(_lowerCamelCase    )    )




 @require_torch
 @slow
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       import torch

       from transformers import BigBirdConfig, BigBirdModel

       # Build sequence
       a						:Union[str, Any] 							=       list(self.big_tokenizer.get_vocab().keys()    )[:10]
       a						:Dict 							=       ''' '''.join(_lowerCamelCase    )
       a						:Tuple 							=       self.big_tokenizer.encode_plus(_lowerCamelCase					,  return_tensors='''pt'''					,  return_token_type_ids=_lowerCamelCase    )
       a						:int 							=       self.big_tokenizer.batch_encode_plus(
           [sequence + ''' ''' + sequence]					,  return_tensors='''pt'''					,  return_token_type_ids=_lowerCamelCase    )

       a						:Union[str, Any] 							=       BigBirdConfig(attention_type='''original_full'''    )
       a						:List[str] 							=       BigBirdModel(_lowerCamelCase    )

       assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

       with torch.no_grad():
             model(**_lowerCamelCase    )
             model(**_lowerCamelCase    )




 @slow
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:int 							=       BigBirdTokenizer.from_pretrained('''google/bigbird-roberta-base'''    )
       a						:str 							=       tokenizer.decode(tokenizer('''Paris is the [MASK].'''    ).input_ids    )

       self.assertTrue(decoded_text == '''[CLS] Paris is the[MASK].[SEP]'''    )




 @slow
 def        SCREAMING_SNAKE_CASE__				(		self    ):
       # fmt: off
       a						:List[Any] 							=       {'''input_ids''': [[65, 3_9286, 458, 3_6335, 2001, 456, 1_3073, 1_3266, 455, 113, 7746, 1741, 1_1157, 391, 1_3073, 1_3266, 455, 113, 3967, 3_5412, 113, 4936, 109, 3870, 2377, 113, 3_0084, 4_5720, 458, 134, 1_7496, 112, 503, 1_1672, 113, 118, 112, 5665, 1_3347, 3_8687, 112, 1496, 3_1389, 112, 3268, 4_7264, 134, 962, 112, 1_6377, 8035, 2_3130, 430, 1_2169, 1_5518, 2_8592, 458, 146, 4_1697, 109, 391, 1_2169, 1_5518, 1_6689, 458, 146, 4_1358, 109, 452, 726, 4034, 111, 763, 3_5412, 5082, 388, 1903, 111, 9051, 391, 2870, 4_8918, 1900, 1123, 550, 998, 112, 9586, 1_5985, 455, 391, 410, 2_2955, 3_7636, 114, 66], [65, 448, 1_7496, 419, 3663, 385, 763, 113, 2_7533, 2870, 3283, 1_3043, 1639, 2_4713, 523, 656, 2_4013, 1_8550, 2521, 517, 2_7014, 2_1244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 1_1786, 114, 66, 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], [65, 484, 2169, 7687, 2_1932, 1_8146, 726, 363, 1_7032, 3391, 114, 66, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0], [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, 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=_lowerCamelCase					,  model_name='''google/bigbird-roberta-base'''					,  revision='''215c99f1600e06f83acce68422f2035b2b5c3510'''					,  )









import string

import numpy
def 				__lowerCamelCase						( UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		int						):




      """simple docstring"""





      return b if a == 0 else greatest_common_divisor(b % a ,  UpperCAmelCase_						)







class 		_snake_case  :
 SCREAMING_SNAKE_CASE__      =       string.ascii_uppercase + string.digits
 # This cipher takes alphanumerics into account
 # i.e. a total of 36 characters

 # take x and return x % len(key_string)
 SCREAMING_SNAKE_CASE__      =       numpy.vectorize(lambda _snake_case							: x % 36							)

 SCREAMING_SNAKE_CASE__      =       numpy.vectorize(_snake_case							)




 def __init__(		self					,  _lowerCamelCase    ):
       a						:List[Any] 							=       self.modulus(_lowerCamelCase    )  # mod36 calc's on the encrypt key
       self.check_determinant()  # validate the determinant of the encryption key
       a						:int 							=       encrypt_key.shape[0]




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase    ):
       return self.key_string.index(_lowerCamelCase    )




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase    ):
       return self.key_string[round(_lowerCamelCase    )]




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:str 							=       round(numpy.linalg.det(self.encrypt_key    )    )

       if det < 0:
             a						:Any 							=       det % len(self.key_string    )

       a						:Dict 							=       len(self.key_string    )
       if greatest_common_divisor(_lowerCamelCase					,  len(self.key_string    )    ) != 1:
             a						:int 							=       (
                 F'''determinant modular {req_l} of encryption key({det}) '''
                 F'''is not co prime w.r.t {req_l}.\nTry another key.'''
             )
             raise ValueError(_lowerCamelCase    )




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase    ):
       a						:Optional[Any] 							=       [char for char in text.upper() if char in self.key_string]

       a						:List[str] 							=       chars[-1]
       while len(_lowerCamelCase    ) % self.break_key != 0:
             chars.append(_lowerCamelCase    )

       return "".join(_lowerCamelCase    )




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase    ):
       a						:Dict 							=       self.process_text(text.upper()    )
       a						:List[str] 							=       ''''''

       for i in range(0					,  len(_lowerCamelCase    ) - self.break_key + 1					,  self.break_key    ):
             a						:int 							=       text[i : i + self.break_key]
             a						:Optional[int] 							=       [self.replace_letters(_lowerCamelCase    ) for char in batch]
             a						:Union[str, Any] 							=       numpy.array([vec]    ).T
             a						:str 							=       self.modulus(self.encrypt_key.dot(_lowerCamelCase    )    ).T.tolist()[
                 0
             ]
             a						:List[Any] 							=       ''''''.join(
                 self.replace_digits(_lowerCamelCase    ) for num in batch_encrypted    )
             encrypted += encrypted_batch

       return encrypted




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:List[Any] 							=       round(numpy.linalg.det(self.encrypt_key    )    )

       if det < 0:
             a						:int 							=       det % len(self.key_string    )
       a						:Tuple 							=       None
       for i in range(len(self.key_string    )    ):
             if (det * i) % len(self.key_string    ) == 1:
                   a						:Tuple 							=       i
                   break

       a						:List[str] 							=       (
           det_inv
           * numpy.linalg.det(self.encrypt_key    )
           * numpy.linalg.inv(self.encrypt_key    )
       )

       return self.to_int(self.modulus(_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase    ):
       a						:List[Any] 							=       self.make_decrypt_key()
       a						:str 							=       self.process_text(text.upper()    )
       a						:List[Any] 							=       ''''''

       for i in range(0					,  len(_lowerCamelCase    ) - self.break_key + 1					,  self.break_key    ):
             a						:Optional[Any] 							=       text[i : i + self.break_key]
             a						:List[Any] 							=       [self.replace_letters(_lowerCamelCase    ) for char in batch]
             a						:str 							=       numpy.array([vec]    ).T
             a						:Dict 							=       self.modulus(decrypt_key.dot(_lowerCamelCase    )    ).T.tolist()[0]
             a						:List[Any] 							=       ''''''.join(
                 self.replace_digits(_lowerCamelCase    ) for num in batch_decrypted    )
             decrypted += decrypted_batch

       return decrypted







def 				__lowerCamelCase						( ):




      """simple docstring"""





      a						:Tuple 							=       int(input('''Enter the order of the encryption key: '''						)						)
      a						:Dict 							=       []

      print('''Enter each row of the encryption key with space separated integers'''						)
      for _ in range(UpperCAmelCase_						):
            a						:List[str] 							=       [int(UpperCAmelCase_						) for x in input().split()]
            hill_matrix.append(UpperCAmelCase_						)

      a						:Any 							=       HillCipher(numpy.array(UpperCAmelCase_						)						)

      print('''Would you like to encrypt or decrypt some text? (1 or 2)'''						)
      a						:Any 							=       input('''\n1. Encrypt\n2. Decrypt\n'''						)
      if option == "1":
            a						:str 							=       input('''What text would you like to encrypt?: '''						)
            print('''Your encrypted text is:'''						)
            print(hc.encrypt(UpperCAmelCase_						)						)
      elif option == "2":
            a						:Dict 							=       input('''What text would you like to decrypt?: '''						)
            print('''Your decrypted text is:'''						)
            print(hc.decrypt(UpperCAmelCase_						)						)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     main()





