






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      Namespace     )    ->   Dict:





    """simple docstring"""

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


__a   :							Dict						= "\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    __lowercase   (						lowercase_	):







     '''simple docstring'''




     @staticmethod
     def 		lowerCAmelCase_  (					UpperCamelCase_							:      ArgumentParser					):


         """simple docstring"""



         __A       =						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							:      int			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      str			,						UpperCamelCase_							:      str			,						*UpperCamelCase_							:      int			,						):


         """simple docstring"""



         __A       =						logging.get_logger("""transformers-cli/converting"""					)

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





     def 		lowerCAmelCase_  (					self							:      int					):


         """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(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():
                 __A       =						self._tf_checkpoint
                 __A       =						""""""
             else:
                 __A       =						self._tf_checkpoint
                 __A       =						""""""
             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]"""					)












def       _SCREAMING_SNAKE_CASE    (			__lowercase :      int     )    ->   list[int]:





    """simple docstring"""

    if length <= 0 or not isinstance(__lowercase      ,					__lowercase     ):
        raise ValueError("""Length must be a positive integer."""     )
    return [n * (2 * n - 1) for n in range(__lowercase     )]


if __name__ == "__main__":
  print(hexagonal_numbers(length=5))
  print(hexagonal_numbers(length=10))




