




from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def 							lowercase					(snake_case__   : Namespace )     ->  int:


				'''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       SCREAMING_SNAKE_CASE__					(					__lowerCAmelCase					):


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


						def __init__(							self				:			Optional[Any]						,						lowerCAmelCase				:			str						,						lowerCAmelCase				:			str						,						lowerCAmelCase				:			str						,						lowerCAmelCase				:			str						,						lowerCAmelCase				:			str						,						*lowerCAmelCase				:			Optional[int]						,						):
										lowerCAmelCase  =				logging.get_logger("""transformers-cli/converting"""					)

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




						def   __lowercase (							self				:			Optional[Any]					):






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

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

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

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

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

														if "ckpt" in self._tf_checkpoint.lower():
																		lowerCAmelCase  =				self._tf_checkpoint
																		lowerCAmelCase  =				''''''
														else:
																		lowerCAmelCase  =				self._tf_checkpoint
																		lowerCAmelCase  =				''''''
														convert_transfo_xl_checkpoint_to_pytorch(
														    lowerCamelCase__						,						self._config						,						self._pytorch_dump_output						,						lowerCamelCase__					)
										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(lowerCamelCase__					)

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

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

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


a      =							'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'





def 							lowercase					()     ->  Optional[Any]:


				'''simple docstring'''






				lowerCAmelCase  =				_ask_options(
				    """In which compute environment are you running?"""      ,       ["""This machine""", """AWS (Amazon SageMaker)"""]      ,       _convert_compute_environment      ,       )
				if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
								lowerCAmelCase  =				get_sagemaker_input()
				else:
								lowerCAmelCase  =				get_cluster_input()
				return config





def 							lowercase					(snake_case__   : List[str]=None )     ->  int:


				'''simple docstring'''






				if subparsers is not None:
								lowerCAmelCase  =				subparsers.add_parser("""config"""      ,       description=snake_case__ )
				else:
								lowerCAmelCase  =				argparse.ArgumentParser("""Accelerate config command"""      ,       description=snake_case__ )

				parser.add_argument(
				    """--config_file"""      ,       default=snake_case__      ,       help=(
				        """The path to use to store the config file. Will default to a file named default_config.yaml in the cache """
				        """location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have """
				        """such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed """
				        """with 'huggingface'."""
				    )      ,       )

				if subparsers is not None:
								parser.set_defaults(func=snake_case__ )
				return parser





def 							lowercase					(snake_case__   : str )     ->  Optional[Any]:


				'''simple docstring'''






				lowerCAmelCase  =				get_user_input()
				if args.config_file is not None:
								lowerCAmelCase  =				args.config_file
				else:
								if not os.path.isdir(snake_case__ ):
												os.makedirs(snake_case__ )
								lowerCAmelCase  =				default_yaml_config_file

				if config_file.endswith(""".json""" ):
								config.to_json_file(snake_case__ )
				else:
								config.to_yaml_file(snake_case__ )
				print(f'''accelerate configuration saved at {config_file}''' )





def 							lowercase					()     ->  Optional[int]:


				'''simple docstring'''






				lowerCAmelCase  =				config_command_parser()
				lowerCAmelCase  =				parser.parse_args()
				config_command(snake_case__ )


if __name__ == "__main__":
		main()





