





import math




def    A_(			A				,      A   ):
	if (
	    not isinstance(A				,      (int, float)   )
	    or power_factor < -1
	    or power_factor > 1
	):
		raise ValueError("""power_factor must be a valid float value between -1 and 1."""   )
	return apparent_power * power_factor




def    A_(			A				,      A   ):
	if (
	    not isinstance(A				,      (int, float)   )
	    or power_factor < -1
	    or power_factor > 1
	):
		raise ValueError("""power_factor must be a valid float value between -1 and 1."""   )
	return apparent_power * math.sqrt(1 - power_factor**2   )


if __name__ == "__main__":
				import doctest

				doctest.testmod()









from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def    A_(			A   ):
	return ConvertCommand(
	    args.model_type				,      args.tf_checkpoint				,      args.pytorch_dump_output				,      args.config				,      args.finetuning_task_name   )


UpperCamelCase__   : Any					  = """
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  (       A_  ):







					'''simple docstring'''

					@staticmethod
					def        SCREAMING_SNAKE_CASE							(						__lowercase    :  ArgumentParser		):






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





					def __init__(						self    :  Optional[int] ,					__lowercase    :  str ,					__lowercase    :  str ,					__lowercase    :  str ,					__lowercase    :  str ,					__lowercase    :  str ,					*__lowercase    :  Tuple ,					):






						'''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        SCREAMING_SNAKE_CASE							(						self    :  List[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(__lowercase		)

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

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

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

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

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

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

							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]"""		)


