


"""simple docstring"""





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand


def      _snake_case						(						_snake_case				:			Namespace			):
      return ConvertCommand(
          args.model_type ,   args.tf_checkpoint ,   args.pytorch_dump_output ,   args.config ,   args.finetuning_task_name			)


snake_case__		:     str    				=				'''
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 		snake_case_(       a__			):






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






     def __init__(	self  :					Any					,				UpperCamelCase_  :					str					,				UpperCamelCase_  :					str					,				UpperCamelCase_  :					str					,				UpperCamelCase_  :					str					,				UpperCamelCase_  :					str					,				*UpperCamelCase_  :					Optional[Any]					,				):
           lowerCAmelCase					:	List[Any]       =   logging.get_logger('''transformers-cli/converting'''				)

           self._logger.info(F'''Loading model {model_type}'''				)
           lowerCAmelCase					:	List[str]       =   model_type
           lowerCAmelCase					:	Tuple       =   tf_checkpoint
           lowerCAmelCase					:	List[Any]       =   pytorch_dump_output
           lowerCAmelCase					:	str       =   config
           lowerCAmelCase					:	int       =   finetuning_task_name






     def      lowerCamelCase__     (	self  :					Dict				):
           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(UpperCamelCase_				)

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

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

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

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

                 if "ckpt" in self._tf_checkpoint.lower():
                       lowerCAmelCase					:	Any       =   self._tf_checkpoint
                       lowerCAmelCase					:	Tuple       =   ''''''
                 else:
                       lowerCAmelCase					:	Union[str, Any]       =   self._tf_checkpoint
                       lowerCAmelCase					:	List[Any]       =   ''''''
                 convert_transfo_xl_checkpoint_to_pytorch(
                     UpperCamelCase_					,				self._config					,				self._pytorch_dump_output					,				UpperCamelCase_				)
           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(UpperCamelCase_				)

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

                 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"""





def      _snake_case						(						_snake_case				:			int ,   _snake_case				:			int			):
      return base * power(_snake_case ,   (exponent - 1)			) if exponent else 1


if __name__ == "__main__":
 print('''Raise base to the power of exponent using recursion...''')
 snake_case__		:     Union[str, Any]    				=				int(input('''Enter the base: ''').strip())
 snake_case__		:     Optional[Any]    				=				int(input('''Enter the exponent: ''').strip())
 snake_case__		:     Any    				=				power(base, abs(exponent))
 if exponent < 0:  # power() does not properly deal w/ negative exponents
  snake_case__		:     Dict    				=				1 / result
 print(f"""{base} to the power of {exponent} is {result}""")


