


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						Tuple:


						'''simple docstring'''






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


A				:       int      =  '\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      UpperCamelCase(	_a ):


					@staticmethod
					def 				SCREAMING_SNAKE_CASE_	(    SCREAMING_SNAKE_CASE						:		ArgumentParser    )      ->						Optional[Any]:




											'''simple docstring'''

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


					def __init__(    self						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		str  ,     *SCREAMING_SNAKE_CASE						:		Tuple  ,     )      ->						str:




											'''simple docstring'''

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

											self._logger.info(f'''Loading model {model_type}'''    )
											__snake_case				=		model_type
											__snake_case				=		tf_checkpoint
											__snake_case				=		pytorch_dump_output
											__snake_case				=		config
											__snake_case				=		finetuning_task_name






					def 				SCREAMING_SNAKE_CASE_	(    self						:		int    )      ->						Any:




											'''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(SCREAMING_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(SCREAMING_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(SCREAMING_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(SCREAMING_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(SCREAMING_SNAKE_CASE    )

																	if "ckpt" in self._tf_checkpoint.lower():
																							__snake_case				=		self._tf_checkpoint
																							__snake_case				=		""
																	else:
																							__snake_case				=		self._tf_checkpoint
																							__snake_case				=		""
																	convert_transfo_xl_checkpoint_to_pytorch(
																	    SCREAMING_SNAKE_CASE  ,     self._config  ,     self._pytorch_dump_output  ,     SCREAMING_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(SCREAMING_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(SCREAMING_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]"    )









import inspect
import unittest






class      UpperCamelCase(	unittest.TestCase ):


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						List[Any]:




											'''simple docstring'''

											try:
																	import diffusers  # noqa: F401
											except ImportError:
																	assert False






					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]    )      ->						Any:




											'''simple docstring'''

											import diffusers
											from diffusers.dependency_versions_table import deps

											__snake_case				=		inspect.getmembers(SCREAMING_SNAKE_CASE  ,     inspect.isclass    )

											for cls_name, cls_module in all_classes:
																	if "dummy_" in cls_module.__module__:
																							for backend in cls_module._backends:
																													if backend == "k_diffusion":
																																			__snake_case				=		"k-diffusion"
																													elif backend == "invisible_watermark":
																																			__snake_case				=		"invisible-watermark"
																													assert backend in deps, f'''{backend} is not in the deps table!'''





