





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def lowerCAmelCase__(__snake_case							)       ->   List[str]:







	'''simple docstring'''







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


_a						=   "\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n"






class       __A					(					lowerCAmelCase				):

			'''simple docstring'''







			@staticmethod
			def 	__lowerCamelCase       (					__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	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=__lowerCAmelCase ,						required=__lowerCAmelCase ,						help='''Model\'s type.'''							)
				train_parser.add_argument(
				    '''--tf_checkpoint''' ,						type=__lowerCAmelCase ,						required=__lowerCAmelCase ,						help='''TensorFlow checkpoint path or folder.'''							)
				train_parser.add_argument(
				    '''--pytorch_dump_output''' ,						type=__lowerCAmelCase ,						required=__lowerCAmelCase ,						help='''Path to the PyTorch saved model output.'''							)
				train_parser.add_argument('''--config''' ,						type=__lowerCAmelCase ,						default='''''' ,						help='''Configuration file path or folder.'''							)
				train_parser.add_argument(
				    '''--finetuning_task_name''' ,						type=__lowerCAmelCase ,						default=__lowerCAmelCase ,						help='''Optional fine-tuning task name if the TF model was a finetuned model.''' ,						)
				train_parser.set_defaults(func=__lowerCAmelCase							)





			def __init__(					self ,						__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase ,						*__lowerCAmelCase ,						):



				'''simple docstring'''







				lowerCamelCase__              =	logging.get_logger('''transformers-cli/converting'''							)

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





			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				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(__lowerCAmelCase							)

					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(__lowerCAmelCase							)

					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(__lowerCAmelCase							)

					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(__lowerCAmelCase							)

					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(__lowerCAmelCase							)

					if "ckpt" in self._tf_checkpoint.lower():
						lowerCamelCase__              =	self._tf_checkpoint
						lowerCamelCase__              =	''''''
					else:
						lowerCamelCase__              =	self._tf_checkpoint
						lowerCamelCase__              =	''''''
					convert_transfo_xl_checkpoint_to_pytorch(
					    __lowerCAmelCase ,						self._config ,						self._pytorch_dump_output ,						__lowerCAmelCase							)
				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(__lowerCAmelCase							)

					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(__lowerCAmelCase							)

					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]'''							)










from __future__ import annotations





def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case							)       ->   float:







	'''simple docstring'''







	if days_between_payments <= 0:
		raise ValueError('''days_between_payments must be > 0'''							)
	if daily_interest_rate < 0:
		raise ValueError('''daily_interest_rate must be >= 0'''							)
	if principal <= 0:
		raise ValueError('''principal must be > 0'''							)
	return principal * daily_interest_rate * days_between_payments





def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,)       ->   float:







	'''simple docstring'''







	if number_of_compounding_periods <= 0:
		raise ValueError('''number_of_compounding_periods must be > 0'''							)
	if nominal_annual_interest_rate_percentage < 0:
		raise ValueError('''nominal_annual_interest_rate_percentage must be >= 0'''							)
	if principal <= 0:
		raise ValueError('''principal must be > 0'''							)

	return principal * (
	    (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
	    - 1
	)





def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,)       ->   float:







	'''simple docstring'''







	if number_of_years <= 0:
		raise ValueError('''number_of_years must be > 0'''							)
	if nominal_annual_percentage_rate < 0:
		raise ValueError('''nominal_annual_percentage_rate must be >= 0'''							)
	if principal <= 0:
		raise ValueError('''principal must be > 0'''							)

	return compound_interest(
	    __snake_case ,nominal_annual_percentage_rate / 365 ,number_of_years * 365							)


if __name__ == "__main__":
			import doctest

			doctest.testmod()



