





"""simple docstring"""




from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Namespace					) ->int:






	'''simple docstring'''






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


a						: List[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__						):






							@staticmethod
							def     __a   (   lowerCAmelCase__      )	-> Dict:
								a      :		Optional[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=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      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					*lowerCAmelCase__      ,					)	-> int:
								a      :		Optional[Any]	=				logging.get_logger("transformers-cli/converting"      )

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






							def     __a   (   self      )	-> List[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(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():
										a      :		List[Any]	=				self._tf_checkpoint
										a      :		str	=				""
									else:
										a      :		Optional[Any]	=				self._tf_checkpoint
										a      :		Optional[Any]	=				""
									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"""




from decimal import Decimal, getcontext
from math import ceil, factorial






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    int					) ->str:






	'''simple docstring'''






	if not isinstance(_lowercase    ,       _lowercase					):
		raise TypeError("Undefined for non-integers"					)
	elif precision < 1:
		raise ValueError("Undefined for non-natural numbers"					)

	a      :		Tuple	=				precision
	a      :		str	=				ceil(precision / 14					)
	a      :		List[Any]	=				42_6880 * Decimal(1_0005					).sqrt()
	a      :		Union[str, Any]	=				1
	a      :		Dict	=				1359_1409
	a      :		Optional[int]	=				Decimal(_lowercase					)
	for k in range(1    ,       _lowercase					):
		a      :		int	=				factorial(6 * k					) // (factorial(3 * k					) * factorial(_lowercase					) ** 3)
		linear_term += 5_4514_0134
		exponential_term *= -26_2537_4126_4076_8000
		partial_sum += Decimal(multinomial_term * linear_term					) / exponential_term
	return str(constant_term / partial_sum					)[:-1]


if __name__ == "__main__":
		a						: Optional[Any]     	=			50
		print(F'''The first {n} digits of pi is: {pi(n)}''')


