
SCREAMING_SNAKE_CASE							:int							 =				'ABCDEFGHIJKLMNOPQRSTUVWXYZ'


def 						UpperCAmelCase			(	)		->	None:







				"""simple docstring"""



				__A   			= input("Enter message: "						)
				__A   			= input("Enter key [alphanumeric]: "						)
				__A   			= input("Encrypt/Decrypt [e/d]: "						)

				if mode.lower().startswith("e"						):
								__A   			= "encrypt"
								__A   			= encrypt_message(a_		,   a_						)
				elif mode.lower().startswith("d"						):
								__A   			= "decrypt"
								__A   			= decrypt_message(a_		,   a_						)

				print(F'''\n{mode.title()}ed message:'''						)
				print(a_						)


def 						UpperCAmelCase			(	a_		,   a_						)		->	str:







				"""simple docstring"""



				return translate_message(a_		,   a_		,   "encrypt"						)


def 						UpperCAmelCase			(	a_		,   a_						)		->	str:







				"""simple docstring"""



				return translate_message(a_		,   a_		,   "decrypt"						)


def 						UpperCAmelCase			(	a_		,   a_		,   a_						)		->	str:







				"""simple docstring"""



				__A   			= []
				__A   			= 0
				__A   			= key.upper()

				for symbol in message:
								__A   			= LETTERS.find(symbol.upper()						)
								if num != -1:
												if mode == "encrypt":
																num += LETTERS.find(key[key_index]						)
												elif mode == "decrypt":
																num -= LETTERS.find(key[key_index]						)

												num %= len(a_						)

												if symbol.isupper():
																translated.append(LETTERS[num]						)
												elif symbol.islower():
																translated.append(LETTERS[num].lower()						)

												key_index += 1
												if key_index == len(a_						):
																__A   			= 0
								else:
												translated.append(a_						)
				return "".join(a_						)


if __name__ == "__main__":
					main()







import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()


def 	UpperCamelCase__(       UpperCamelCase__			:       Any ,     UpperCamelCase__			:       int ,     UpperCamelCase__			:       int  )->int:
       # Initialise PyTorch model
       A__											=						BertConfig.from_json_file(UpperCamelCase__  )
       print(f"Building PyTorch model from configuration: {config}"  )
       A__											=						BertForPreTraining(UpperCamelCase__  )

       # Load weights from tf checkpoint
       load_tf_weights_in_bert(UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__  )

       # Save pytorch-model
       print(f"Save PyTorch model to {pytorch_dump_path}"  )
       torch.save(model.state_dict() ,     UpperCamelCase__  )


if __name__ == "__main__":
       a__:      str									=		argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
       )
       parser.add_argument(
           '--bert_config_file',
           default=None,
           type=str,
           required=True,
           help=(
               'The config json file corresponding to the pre-trained BERT model. \n'
               'This specifies the model architecture.'
           ),
       )
       parser.add_argument(
           '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
       )
       a__:      Any									=		parser.parse_args()
       convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





