


import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType

@require_torch
class      lowerCamelCase	:
       _UpperCamelCase    		=      ()
       _UpperCamelCase    		=      True

       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case   : Union[str, Any]	  =      self.config_class

        # test default config
        snake_case   : Tuple	  =      config_class()
        self.assertIsNotNone(a__					)
        snake_case   : List[str]	  =      ['''stem'''] + [f'''stage{idx}''' for idx in range(1	,						len(config.depths					) + 1					)]
        self.assertEqual(config.stage_names	,						a__					)
        self.assertTrue(set(config.out_features					).issubset(set(config.stage_names					)					)					)

        # Test out_features and out_indices are correctly set
        # out_features and out_indices both None
        snake_case   : Tuple	  =      config_class(out_features=a__	,						out_indices=a__					)
        self.assertEqual(config.out_features	,						[config.stage_names[-1]]					)
        self.assertEqual(config.out_indices	,						[len(config.stage_names					) - 1]					)

        # out_features and out_indices both set
        snake_case   : int	  =      config_class(out_features=['''stem''', '''stage1''']	,						out_indices=[0, 1]					)
        self.assertEqual(config.out_features	,						['''stem''', '''stage1''']					)
        self.assertEqual(config.out_indices	,						[0, 1]					)

        # Only out_features set
        snake_case   : int	  =      config_class(out_features=['''stage1''', '''stage3''']					)
        self.assertEqual(config.out_features	,						['''stage1''', '''stage3''']					)
        self.assertEqual(config.out_indices	,						[1, 3]					)

        # Only out_indices set
        snake_case   : Union[str, Any]	  =      config_class(out_indices=[0, 2]					)
        self.assertEqual(config.out_features	,						[config.stage_names[0], config.stage_names[2]]					)
        self.assertEqual(config.out_indices	,						[0, 2]					)

        # Error raised when out_indices do not correspond to out_features
        with self.assertRaises(a__					):
         snake_case   : Union[str, Any]	  =      config_class(out_features=['''stage1''', '''stage2''']	,						out_indices=[0, 2]					)

       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case  ,					snake_case   : str	  =      self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case   : List[Any]	  =      model_class(a__					)
         snake_case   : int	  =      inspect.signature(model.forward					)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         snake_case   : int	  =      [*signature.parameters.keys()]
         snake_case   : int	  =      ['''pixel_values''']
         self.assertListEqual(arg_names[:1]	,						a__					)

       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case  ,					snake_case   : Optional[Any]	  =      self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case   : Dict	  =      model_class(a__					)
         self.assertEqual(len(model.channels					)	,						len(config.out_features					)					)
         snake_case   : Tuple	  =      model.num_features
         snake_case   : List[Any]	  =      [config.stage_names.index(a__					) for feat in config.out_features]
         snake_case   : List[Any]	  =      [num_features[idx] for idx in out_indices]
         self.assertListEqual(model.channels	,						a__					)

         snake_case   : Optional[Any]	  =      copy.deepcopy(a__					)
         snake_case   : Dict	  =      None
         snake_case   : Tuple	  =      model_class(a__					)
         self.assertEqual(len(model.channels					)	,						1					)
         self.assertListEqual(model.channels	,						[num_features[-1]]					)

         snake_case   : int	  =      copy.deepcopy(a__					)
         snake_case   : List[Any]	  =      None
         snake_case   : Union[str, Any]	  =      model_class(a__					)
         self.assertEqual(len(model.channels					)	,						1					)
         self.assertListEqual(model.channels	,						[num_features[-1]]					)

       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case  ,					snake_case   : str	  =      self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case   : Union[str, Any]	  =      model_class(a__					)
         model.to(a__					)
         model.eval()
         snake_case   : Optional[int]	  =      model(**a__					)

         self.assertEqual(len(result.feature_maps					)	,						len(config.out_features					)					)
         self.assertEqual(len(model.channels					)	,						len(config.out_features					)					)
         self.assertEqual(len(result.feature_maps					)	,						len(config.out_indices					)					)
         self.assertEqual(len(model.channels					)	,						len(config.out_indices					)					)

         # Check output of last stage is taken if out_features=None, out_indices=None
         snake_case   : Optional[Any]	  =      copy.deepcopy(a__					)
         snake_case   : str	  =      None
         snake_case   : List[Any]	  =      model_class(a__					)
         model.to(a__					)
         model.eval()
         snake_case   : Optional[Any]	  =      model(**a__					)

         self.assertEqual(len(result.feature_maps					)	,						1					)
         self.assertEqual(len(model.channels					)	,						1					)

         snake_case   : int	  =      copy.deepcopy(a__					)
         snake_case   : List[Any]	  =      None
         snake_case   : int	  =      model_class(a__					)
         model.to(a__					)
         model.eval()
         snake_case   : Optional[Any]	  =      model(**a__					)

         self.assertEqual(len(result.feature_maps					)	,						1					)
         self.assertEqual(len(model.channels					)	,						1					)

         # Check backbone can be initialized with fresh weights
         snake_case   : List[Any]	  =      copy.deepcopy(a__					)
         snake_case   : Union[str, Any]	  =      False
         snake_case   : List[Any]	  =      model_class(a__					)
         model.to(a__					)
         model.eval()
         snake_case   : Union[str, Any]	  =      model(**a__					)

       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case  ,					snake_case   : str	  =      self.model_tester.prepare_config_and_inputs_for_common()

        for backbone_class in self.all_model_classes:
         snake_case   : List[str]	  =      backbone_class(a__					)

         self.assertTrue(hasattr(a__	,						'''backbone_type'''					)					)
         self.assertTrue(hasattr(a__	,						'''stage_names'''					)					)
         self.assertTrue(hasattr(a__	,						'''num_features'''					)					)
         self.assertTrue(hasattr(a__	,						'''out_indices'''					)					)
         self.assertTrue(hasattr(a__	,						'''out_features'''					)					)
         self.assertTrue(hasattr(a__	,						'''out_feature_channels'''					)					)
         self.assertTrue(hasattr(a__	,						'''channels'''					)					)

         self.assertIsInstance(backbone.backbone_type	,						a__					)
         # Verify num_features has been initialized in the backbone init
         self.assertIsNotNone(backbone.num_features					)
         self.assertTrue(len(backbone.channels					) == len(backbone.out_indices					)					)
         self.assertTrue(len(backbone.stage_names					) == len(backbone.num_features					)					)
         self.assertTrue(len(backbone.channels					) <= len(backbone.num_features					)					)
         self.assertTrue(len(backbone.out_feature_channels					) == len(backbone.stage_names					)					)



       def 				UpperCAmelCase				(			self					):






        '''simple docstring'''






        snake_case  ,					snake_case   : Optional[int]	  =      self.model_tester.prepare_config_and_inputs_for_common()
        snake_case   : str	  =      inputs_dict['''pixel_values'''].shape[0]

        for backbone_class in self.all_model_classes:
         snake_case   : Union[str, Any]	  =      backbone_class(a__					)
         backbone.to(a__					)
         backbone.eval()

         snake_case   : Optional[int]	  =      backbone(**a__					)

         # Test default outputs and verify feature maps
         self.assertIsInstance(outputs.feature_maps	,						a__					)
         self.assertTrue(len(outputs.feature_maps					) == len(backbone.channels					)					)
         for feature_map, n_channels in zip(outputs.feature_maps	,						backbone.channels					):
          self.assertTrue(feature_map.shape[:2]	,						(batch_size, n_channels)					)
         self.assertIsNone(outputs.hidden_states					)
         self.assertIsNone(outputs.attentions					)

         # Test output_hidden_states=True
         snake_case   : Dict	  =      backbone(**a__	,						output_hidden_states=a__					)
         self.assertIsNotNone(outputs.hidden_states					)
         self.assertTrue(len(outputs.hidden_states					)	,						len(backbone.stage_names					)					)
         for hidden_state, n_channels in zip(outputs.hidden_states	,						backbone.channels					):
          self.assertTrue(hidden_state.shape[:2]	,						(batch_size, n_channels)					)

         # Test output_attentions=True
         if self.has_attentions:
          snake_case   : Dict	  =      backbone(**a__	,						output_attentions=a__					)
          self.assertIsNotNone(outputs.attentions					)










import os
import sys

from . import rsa_key_generator as rkg

a				:							str					=			128
a				:							str					=			256






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase = DEFAULT_BLOCK_SIZE       )		->list[int]:


 '''simple docstring'''
 snake_case   : List[str]	  =      message.encode('''ascii'''       )

 snake_case   : List[Any]	  =      []
 for block_start in range(0 ,     len(__lowerCamelCase       ) ,     __lowerCamelCase       ):
  snake_case   : int	  =      0
  for i in range(__lowerCamelCase ,     min(block_start + block_size ,     len(__lowerCamelCase       )       )       ):
   block_int += message_bytes[i] * (BYTE_SIZE ** (i % block_size))
  block_ints.append(__lowerCamelCase       )
 return block_ints






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase = DEFAULT_BLOCK_SIZE       )		->str:


 '''simple docstring'''
 snake_case   : list[str]	  =      []
 for block_int in block_ints:
  snake_case   : list[str]	  =      []
  for i in range(block_size - 1 ,     -1 ,     -1       ):
   if len(__lowerCamelCase       ) + i < message_length:
    snake_case   : Any	  =      block_int // (BYTE_SIZE**i)
    snake_case   : Optional[Any]	  =      block_int % (BYTE_SIZE**i)
    block_message.insert(0 ,     chr(__lowerCamelCase       )       )
  message.extend(__lowerCamelCase       )
 return "".join(__lowerCamelCase       )






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase = DEFAULT_BLOCK_SIZE       )		->list[int]:


 '''simple docstring'''
 snake_case   : str	  =      []
 snake_case  ,					snake_case   : Optional[Any]	  =      key

 for block in get_blocks_from_text(__lowerCamelCase ,     __lowerCamelCase       ):
  encrypted_blocks.append(pow(__lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase       )       )
 return encrypted_blocks






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase = DEFAULT_BLOCK_SIZE ,     )		->str:


 '''simple docstring'''
 snake_case   : List[Any]	  =      []
 snake_case  ,					snake_case   : List[str]	  =      key
 for block in encrypted_blocks:
  decrypted_blocks.append(pow(__lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase       )       )
 return get_text_from_blocks(__lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase       )






def    _UpperCAmelCase	(   __lowerCamelCase       )		->tuple[int, int, int]:


 '''simple docstring'''
 with open(__lowerCamelCase       ) as fo:
  snake_case   : List[Any]	  =      fo.read()
 snake_case  ,					snake_case  ,					snake_case   : Dict	  =      content.split(''','''       )
 return (int(__lowerCamelCase       ), int(__lowerCamelCase       ), int(__lowerCamelCase       ))






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase = DEFAULT_BLOCK_SIZE ,     )		->str:


 '''simple docstring'''
 snake_case  ,					snake_case  ,					snake_case   : List[Any]	  =      read_key_file(__lowerCamelCase       )
 if key_size < block_size * 8:
  sys.exit(
      '''ERROR: Block size is {} bits and key size is {} bits. The RSA cipher '''
      '''requires the block size to be equal to or greater than the key size. '''
      '''Either decrease the block size or use different keys.'''.format(
          block_size * 8 ,     __lowerCamelCase       )       )

 snake_case   : Any	  =      [str(__lowerCamelCase       ) for i in encrypt_message(__lowerCamelCase ,     (n, e) ,     __lowerCamelCase       )]

 snake_case   : List[str]	  =      ''','''.join(__lowerCamelCase       )
 snake_case   : str	  =      f'''{len(__lowerCamelCase       )}_{block_size}_{encrypted_content}'''
 with open(__lowerCamelCase ,     '''w'''       ) as fo:
  fo.write(__lowerCamelCase       )
 return encrypted_content






def    _UpperCAmelCase	(   __lowerCamelCase ,     __lowerCamelCase       )		->str:


 '''simple docstring'''
 snake_case  ,					snake_case  ,					snake_case   : str	  =      read_key_file(__lowerCamelCase       )
 with open(__lowerCamelCase       ) as fo:
  snake_case   : Dict	  =      fo.read()
 snake_case  ,					snake_case  ,					snake_case   : Union[str, Any]	  =      content.split('''_'''       )
 snake_case   : str	  =      int(__lowerCamelCase       )
 snake_case   : int	  =      int(__lowerCamelCase       )

 if key_size < block_size * 8:
  sys.exit(
      '''ERROR: Block size is {} bits and key size is {} bits. The RSA cipher '''
      '''requires the block size to be equal to or greater than the key size. '''
      '''Did you specify the correct key file and encrypted file?'''.format(
          block_size * 8 ,     __lowerCamelCase       )       )

 snake_case   : str	  =      []
 for block in encrypted_message.split(''','''       ):
  encrypted_blocks.append(int(__lowerCamelCase       )       )

 return decrypt_message(__lowerCamelCase ,     __lowerCamelCase ,     (n, d) ,     __lowerCamelCase       )






def    _UpperCAmelCase	(   )		->None:


 '''simple docstring'''
 snake_case   : List[Any]	  =      '''encrypted_file.txt'''
 snake_case   : Optional[int]	  =      input(R'''Encrypt\Decrypt [e\d]: '''       )

 if response.lower().startswith('''e'''       ):
  snake_case   : Dict	  =      '''encrypt'''
 elif response.lower().startswith('''d'''       ):
  snake_case   : Dict	  =      '''decrypt'''

 if mode == "encrypt":
  if not os.path.exists('''rsa_pubkey.txt'''       ):
   rkg.make_key_files('''rsa''' ,     1024       )

  snake_case   : List[Any]	  =      input('''\nEnter message: '''       )
  snake_case   : Union[str, Any]	  =      '''rsa_pubkey.txt'''
  print(f'''Encrypting and writing to {filename}...'''       )
  snake_case   : List[str]	  =      encrypt_and_write_to_file(__lowerCamelCase ,     __lowerCamelCase ,     __lowerCamelCase       )

  print('''\nEncrypted text:'''       )
  print(__lowerCamelCase       )

 elif mode == "decrypt":
  snake_case   : str	  =      '''rsa_privkey.txt'''
  print(f'''Reading from {filename} and decrypting...'''       )
  snake_case   : int	  =      read_from_file_and_decrypt(__lowerCamelCase ,     __lowerCamelCase       )
  print('''writing decryption to rsa_decryption.txt...'''       )
  with open('''rsa_decryption.txt''' ,     '''w'''       ) as dec:
   dec.write(__lowerCamelCase       )

  print('''\nDecryption:'''       )
  print(__lowerCamelCase       )


if __name__ == "__main__":
  main()






