

'''simple docstring'''

from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def 				UpperCamelCase(					UpperCAmelCase_     ):
 return ConvertCommand(
     args.model_type  ,	args.tf_checkpoint  ,	args.pytorch_dump_output  ,	args.config  ,	args.finetuning_task_name     )


lowercase__         =      '\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_			(    lowercase__							):






     '''simple docstring'''



     @staticmethod
     def        UpperCAmelCase_	(		lowercase_			:					ArgumentParser	)						->     int:
      UpperCAmelCase	:     Optional[int]						 =			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			:					str					,      lowercase_			:					str					,      lowercase_			:					str					,      lowercase_			:					str					,      lowercase_			:					str					,      lowercase_			:					str					,      *lowercase_			:					Any					,      )						->     str:
      UpperCAmelCase	:     Dict						 =			logging.get_logger('transformers-cli/converting'	)

      self._logger.info(f"""Loading model {model_type}"""	)
      UpperCAmelCase	:     str						 =			model_type
      UpperCAmelCase	:     Dict						 =			tf_checkpoint
      UpperCAmelCase	:     List[Any]						 =			pytorch_dump_output
      UpperCAmelCase	:     int						 =			config
      UpperCAmelCase	:     int						 =			finetuning_task_name




     def        UpperCAmelCase_	(		self			:					Tuple	)						->     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(_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():
        UpperCAmelCase	:     Optional[int]						 =			self._tf_checkpoint
        UpperCAmelCase	:     List[str]						 =			""""""
       else:
        UpperCAmelCase	:     Any						 =			self._tf_checkpoint
        UpperCAmelCase	:     Tuple						 =			""""""
       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 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_     ):
 if b == 0:
  return 1
 if (b % 2) == 0:
  return actual_power(UpperCAmelCase_  ,	int(b / 2     )     ) * actual_power(UpperCAmelCase_  ,	int(b / 2     )     )
 else:
  return a * actual_power(UpperCAmelCase_  ,	int(b / 2     )     ) * actual_power(UpperCAmelCase_  ,	int(b / 2     )     )




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_     ):
 if b < 0:
  return 1 / actual_power(UpperCAmelCase_  ,	UpperCAmelCase_     )
 return actual_power(UpperCAmelCase_  ,	UpperCAmelCase_     )


if __name__ == "__main__":
 print(power(-2, -3))




