
"""simple docstring"""


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def  lowercase						(	lowerCAmelCase__						):
			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  __lowerCamelCase  ( lowerCAmelCase			):




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




				def __init__(				self							,						UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase							,						*UpperCAmelCase							,						):
							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        UpperCAmelCase__						(				self   ):
							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(UpperCAmelCase   )

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

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

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

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

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

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

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





from math import log

from scipy.constants import Boltzmann, physical_constants

SCREAMING_SNAKE_CASE__   =  300  # TEMPERATURE (unit = K)


def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		float				,		SCREAMING_SNAKE_CASE	:		float				,		SCREAMING_SNAKE_CASE	:		float				,		):







      '''simple docstring'''




      if donor_conc <= 0:
            raise ValueError("""Donor concentration should be positive"""     )
      elif acceptor_conc <= 0:
            raise ValueError("""Acceptor concentration should be positive"""     )
      elif intrinsic_conc <= 0:
            raise ValueError("""Intrinsic concentration should be positive"""     )
      elif donor_conc <= intrinsic_conc:
            raise ValueError(
                """Donor concentration should be greater than intrinsic concentration"""     )
      elif acceptor_conc <= intrinsic_conc:
            raise ValueError(
                """Acceptor concentration should be greater than intrinsic concentration"""     )
      else:
            return (
                Boltzmann
                * T
                * log((donor_conc * acceptor_conc) / intrinsic_conc**2     )
                / physical_constants["electron volt"][0]
            )


if __name__ == "__main__":
       import doctest

       doctest.testmod()






