

"""simple docstring"""


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def        a__       (       __SCREAMING_SNAKE_CASE					)      ->      Optional[Any]:
		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        snake_case      (							__snake_case    ):

				@staticmethod
				def 				lowercase_	(      UpperCamelCase__				:							List[Any])->  str:



						'''simple docstring'''


						__lowerCAmelCase:			Dict        =     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				:							Tuple	,    UpperCamelCase__				:							Union[str, Any]	,    UpperCamelCase__				:							int	,    UpperCamelCase__				:							Union[str, Any]	,    UpperCamelCase__				:							Dict	,    UpperCamelCase__				:							Dict	,    *UpperCamelCase__				:							Union[str, Any]	,    )->  Dict:



						'''simple docstring'''


						__lowerCAmelCase:			List[Any]        =     logging.get_logger("transformers-cli/converting")

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




				def 				lowercase_	(      self				:							Tuple)->  str:



						'''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:			Dict        =     self._tf_checkpoint
										__lowerCAmelCase:			str        =     ""
								else:
										__lowerCAmelCase:			Dict        =     self._tf_checkpoint
										__lowerCAmelCase:			Optional[Any]        =     ""
								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]")









'''simple docstring'''


from __future__ import annotations


def 						__a(SCREAMING_SNAKE_CASE_	:       list     ):



    '''simple docstring'''





    if not nums:
        raise ValueError("List is empty"     )
    return sum(SCREAMING_SNAKE_CASE_     ) / len(SCREAMING_SNAKE_CASE_     )


if __name__ == "__main__":
       import doctest

       doctest.testmod()


