





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def 							_lowerCAmelCase (  _a   :					Namespace			)	->			List[Any]:
     return ConvertCommand(
         args.model_type					,   args.tf_checkpoint					,   args.pytorch_dump_output					,   args.config					,   args.finetuning_task_name			)


UpperCAmelCase_					:   Union[str, Any] 							=						'''
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      lowercase__    (							SCREAMING_SNAKE_CASE__  ):







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







  def __init__(	self    ,						_lowercase    ,						_lowercase    ,						_lowercase    ,						_lowercase    ,						_lowercase    ,						*_lowercase    ,						):
       lowerCAmelCase_					:       Tuple    =		logging.get_logger("""transformers-cli/converting"""						)

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







  def 	UpperCAmelCase__		(	self						):

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

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

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

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

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

            if "ckpt" in self._tf_checkpoint.lower():
                 lowerCAmelCase_					:       Optional[int]    =		self._tf_checkpoint
                 lowerCAmelCase_					:       str    =		""""""
            else:
                 lowerCAmelCase_					:       List[Any]    =		self._tf_checkpoint
                 lowerCAmelCase_					:       str    =		""""""
            convert_transfo_xl_checkpoint_to_pytorch(
                _lowercase    ,						self._config    ,						self._pytorch_dump_output    ,						_lowercase						)
       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(_lowercase						)

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

            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 collections.abc import Sequence






def 							_lowerCAmelCase (  _a   :					Sequence[float]					,   _a   :					bool = False			)	->			float:
     if not arr:
          return 0

     lowerCAmelCase_					:       List[str]    =		0 if allow_empty_subarrays else float("""-inf"""			)
     lowerCAmelCase_					:       List[Any]    =		0.0
     for num in arr:
          lowerCAmelCase_					:       int    =		max(0 if allow_empty_subarrays else num					,   curr_sum + num			)
          lowerCAmelCase_					:       List[str]    =		max(_a					,   _a			)

     return max_sum


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      UpperCAmelCase_					:   int 							=						[-2, 1, -3, 4, -1, 2, 1, -5, 4]
      print(F"""{max_subarray_sum(nums) = }""")
