



from typing import TYPE_CHECKING

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


UpperCAmelCase   :							Any							 ={
    """configuration_chinese_clip""": [
        """CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """ChineseCLIPConfig""",
        """ChineseCLIPOnnxConfig""",
        """ChineseCLIPTextConfig""",
        """ChineseCLIPVisionConfig""",
    ],
    """processing_chinese_clip""": ["""ChineseCLIPProcessor"""],
}

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase   :							Dict							 =["""ChineseCLIPFeatureExtractor"""]
	UpperCAmelCase   :							List[str]							 =["""ChineseCLIPImageProcessor"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	UpperCAmelCase   :							List[Any]							 =[
	    """CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """ChineseCLIPModel""",
	    """ChineseCLIPPreTrainedModel""",
	    """ChineseCLIPTextModel""",
	    """ChineseCLIPVisionModel""",
	]

if TYPE_CHECKING:
	from .configuration_chinese_clip import (
	    CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    ChineseCLIPConfig,
	    ChineseCLIPOnnxConfig,
	    ChineseCLIPTextConfig,
	    ChineseCLIPVisionConfig,
	)
	from .processing_chinese_clip import ChineseCLIPProcessor

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_chinese_clip import (
		    CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    ChineseCLIPModel,
		    ChineseCLIPPreTrainedModel,
		    ChineseCLIPTextModel,
		    ChineseCLIPVisionModel,
		)

else:
	import sys

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





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   :							Dict							 ="""
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   (a_      ):
				'''simple docstring'''







				@staticmethod
				def       _lowerCamelCase					( snake_case__    ):

									'''simple docstring'''


									UpperCamelCase_		  =   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     , snake_case__     , snake_case__     , snake_case__     , snake_case__     , snake_case__     , *snake_case__     , ):

									'''simple docstring'''


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

									self._logger.info(F"""Loading model {model_type}"""    )
									UpperCamelCase_		  =   model_type
									UpperCamelCase_		  =   tf_checkpoint
									UpperCamelCase_		  =   pytorch_dump_output
									UpperCamelCase_		  =   config
									UpperCamelCase_		  =   finetuning_task_name

				def       _lowerCamelCase					( self    ):

									'''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():
																			UpperCamelCase_		  =   self._tf_checkpoint
																			UpperCamelCase_		  =   ""
														else:
																			UpperCamelCase_		  =   self._tf_checkpoint
																			UpperCamelCase_		  =   ""
														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]"    )
