




from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def 		lowerCAmelCase_ (						lowerCamelCase ):
				return ConvertCommand(
				    args.model_type						,  args.tf_checkpoint						,  args.pytorch_dump_output						,  args.config						,  args.finetuning_task_name )


UpperCAmelCase_		:					Tuple          =  "\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   (      UpperCamelCase__      ):

						@staticmethod
						def      A__    (		__snake_case :ArgumentParser			):
										'''simple docstring'''

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

						def __init__(		self :Any     ,			__snake_case :str     ,			__snake_case :str     ,			__snake_case :str     ,			__snake_case :str     ,			__snake_case :str     ,			*__snake_case :Optional[Any]     ,			):
										'''simple docstring'''

										__magic_name__						:						Union[str, Any]										=logging.get_logger("""transformers-cli/converting"""			)

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


						def      A__    (		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(__snake_case			)

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

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

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

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

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

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

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

# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCAmelCase				:      Optional[int]						      ={
    "configuration_vivit": ["VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VivitConfig"],
}
try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase				:      int						      =["VivitImageProcessor"]


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase				:      int						      =[
      "VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "VivitModel",
      "VivitPreTrainedModel",
      "VivitForVideoClassification",
  ]


if TYPE_CHECKING:
  from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_vivit import VivitImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vivit import (
        VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
        VivitForVideoClassification,
        VivitModel,
        VivitPreTrainedModel,
    )


else:
  import sys

  __lowerCAmelCase				:      List[Any]						      =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



