



"""simple docstring"""
from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand
def    A_  (			_lowercase	):







						'''simple docstring'''


						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 				lowerCamelCase  (			_lowerCAmelCase				):






					'''simple docstring'''





					@staticmethod
					def    lowerCAmelCase_				(       snake_case:							ArgumentParser						)   ->	List[str]:
											snake_case_ :Union[str, Any]						=			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:							Optional[int]						,     snake_case:							str						,     snake_case:							str						,     snake_case:							str						,     snake_case:							str						,     snake_case:							str						,     *snake_case:							Dict						,     )   ->	List[Any]:
											snake_case_ :Union[str, Any]						=			logging.get_logger("""transformers-cli/converting"""						)

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






					def    lowerCAmelCase_				(       self:							str						)   ->	Tuple:
											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():
																							snake_case_ :Tuple						=			self._tf_checkpoint
																							snake_case_ :List[Any]						=			""""""
																	else:
																							snake_case_ :Union[str, Any]						=			self._tf_checkpoint
																							snake_case_ :Union[str, Any]						=			""""""
																	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"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a      =				{
    "configuration_altclip": [
        "ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AltCLIPConfig",
        "AltCLIPTextConfig",
        "AltCLIPVisionConfig",
    ],
    "processing_altclip": ["AltCLIPProcessor"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a      =				[
						    "ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "AltCLIPPreTrainedModel",
						    "AltCLIPModel",
						    "AltCLIPTextModel",
						    "AltCLIPVisionModel",
						]


if TYPE_CHECKING:
						from .configuration_altclip import (
						    ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    AltCLIPConfig,
						    AltCLIPTextConfig,
						    AltCLIPVisionConfig,
						)
						from .processing_altclip import AltCLIPProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_altclip import (
												    ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    AltCLIPModel,
												    AltCLIPPreTrainedModel,
												    AltCLIPTextModel,
												    AltCLIPVisionModel,
												)


else:
						import sys

						__a      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
