

from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand



def   __UpperCAmelCase					(      __a :     Namespace      )     ->	Dict:

					"""simple docstring"""

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


a__												=						'''
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 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







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


							def __init__(     self			,				_a			,				_a			,				_a			,				_a			,				_a			,				*_a			,				)       ->       Tuple:
												_a      :       str   =						logging.get_logger('''transformers-cli/converting'''			)

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




							def 							__lowercase							(     self			)       ->       str:
												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(_a			)

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

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

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

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

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

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

																	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 Inc. 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

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
							from PIL import Image







class 							SCREAMING_SNAKE_CASE   (						a_			):






					"""simple docstring"""



					lowercase__												=			"Salesforce/blip-image-captioning-base"
					lowercase__												=			(
					    "This is a tool that generates a description of an image. It takes an input named `image` which should be the "
					    "image to caption, and returns a text that contains the description in English."
					)
					lowercase__												=			"image_captioner"
					lowercase__												=			AutoModelForVisionaSeq

					lowercase__												=			["image"]
					lowercase__												=			["text"]







					def __init__(			self     :							int  ,*lowercase_     :							int  ,**lowercase_     :							List[str]						):
						requires_backends(self  ,['''vision''']						)
						super().__init__(*lowercase_  ,**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							List[str]  ,lowercase_     :							"Image"						):
						return self.pre_processor(images=lowercase_  ,return_tensors='''pt'''						)







					def 			__lowerCAmelCase					(			self     :							List[Any]  ,lowercase_     :							Any						):
						return self.model.generate(**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Dict  ,lowercase_     :							Union[str, Any]						):
						return self.pre_processor.batch_decode(lowercase_  ,skip_special_tokens=lowercase_						)[0].strip()




