





"""simple docstring"""





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		return ConvertCommand(
		    args.model_type  ,	args.tf_checkpoint  ,	args.pytorch_dump_output  ,	args.config  ,	args.finetuning_task_name    )


lowerCAmelCase__     			=			'''
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
'''






class        _lowerCamelCase      (       _lowercase ):


						@staticmethod
						def     snake_case_   (__a		) ->   Union[str, Any]:
								UpperCamelCase   =	parser.add_parser(
								    "convert"   ,							help="CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints."   ,							)
								train_parser.add_argument("--model_type"   ,							type=__a   ,							required=__a   ,							help="Model's type."		)
								train_parser.add_argument(
								    "--tf_checkpoint"   ,							type=__a   ,							required=__a   ,							help="TensorFlow checkpoint path or folder."		)
								train_parser.add_argument(
								    "--pytorch_dump_output"   ,							type=__a   ,							required=__a   ,							help="Path to the PyTorch saved model output."		)
								train_parser.add_argument("--config"   ,							type=__a   ,							default=""   ,							help="Configuration file path or folder."		)
								train_parser.add_argument(
								    "--finetuning_task_name"   ,							type=__a   ,							default=__a   ,							help="Optional fine-tuning task name if the TF model was a finetuned model."   ,							)
								train_parser.set_defaults(func=__a		)


						def __init__(self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							*__a   ,							) ->   Dict:
								UpperCamelCase   =	logging.get_logger("transformers-cli/converting"		)

								self._logger.info(F"Loading model {model_type}"		)
								UpperCamelCase   =	model_type
								UpperCamelCase   =	tf_checkpoint
								UpperCamelCase   =	pytorch_dump_output
								UpperCamelCase   =	config
								UpperCamelCase   =	finetuning_task_name




						def     snake_case_   (self		) ->   Union[str, Any]:
								if self._model_type == "albert":
										try:
												from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
												    convert_tf_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "bert":
										try:
												from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
												    convert_tf_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "funnel":
										try:
												from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
												    convert_tf_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "t5":
										try:
												from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
										except ImportError:
												raise ImportError(__a		)

										convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "gpt":
										from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
										    convert_openai_checkpoint_to_pytorch,
										)

										convert_openai_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "transfo_xl":
										try:
												from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
												    convert_transfo_xl_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										if "ckpt" in self._tf_checkpoint.lower():
												UpperCamelCase   =	self._tf_checkpoint
												UpperCamelCase   =	""
										else:
												UpperCamelCase   =	self._tf_checkpoint
												UpperCamelCase   =	""
										convert_transfo_xl_checkpoint_to_pytorch(
										    __a   ,							self._config   ,							self._pytorch_dump_output   ,							__a		)
								elif self._model_type == "gpt2":
										try:
												from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
												    convert_gpta_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								elif self._model_type == "xlnet":
										try:
												from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
												    convert_xlnet_checkpoint_to_pytorch,
												)
										except ImportError:
												raise ImportError(__a		)

										convert_xlnet_checkpoint_to_pytorch(
										    self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output   ,							self._finetuning_task_name		)
								elif self._model_type == "xlm":
										from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
										    convert_xlm_checkpoint_to_pytorch,
										)

										convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._pytorch_dump_output		)
								elif self._model_type == "lxmert":
										from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
										    convert_lxmert_checkpoint_to_pytorch,
										)

										convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._pytorch_dump_output		)
								elif self._model_type == "rembert":
										from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
										    convert_rembert_tf_checkpoint_to_pytorch,
										)

										convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,							self._config   ,							self._pytorch_dump_output		)
								else:
										raise ValueError(
										    "--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]"		)













"""simple docstring"""





import string


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		for key in range(len(string.ascii_uppercase    )    ):
				UpperCamelCase   =	""
				for symbol in message:
						if symbol in string.ascii_uppercase:
								UpperCamelCase   =	string.ascii_uppercase.find(_SCREAMING_SNAKE_CASE    )
								UpperCamelCase   =	num - key
								if num < 0:
										UpperCamelCase   =	num + len(string.ascii_uppercase    )
								UpperCamelCase   =	translated + string.ascii_uppercase[num]
						else:
								UpperCamelCase   =	translated + symbol
				print(F"Decryption using Key #{key}: {translated}"    )


def       a__					(					):




		"""simple docstring"""


		UpperCamelCase   =	input("Encrypted message: "    )
		UpperCamelCase   =	message.upper()
		decrypt(_SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()






