



def     UpperCAmelCase__ (							__snake_case						,				__snake_case = 1_000							)   -> str:
  if (not isinstance(__snake_case						,				__snake_case							)) or (digit_position <= 0):
    raise ValueError('''Digit position must be a positive integer'''							)
  elif (not isinstance(__snake_case						,				__snake_case							)) or (precision < 0):
    raise ValueError('''Precision must be a nonnegative integer'''							)

  # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
  # accurate
  _A           =    (
      4 * _subsum(__snake_case						,				1						,				__snake_case							)
      - 2 * _subsum(__snake_case						,				4						,				__snake_case							)
      - _subsum(__snake_case						,				5						,				__snake_case							)
      - _subsum(__snake_case						,				6						,				__snake_case							)
  )

  # return the first hex digit of the fractional part of the result
  return hex(int((sum_result % 1) * 16							)							)[2:]




def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case							)   -> float:
  _A           =    0.0
  for sum_index in range(digit_pos_to_extract + precision							):
    _A           =    8 * sum_index + denominator_addend
    if sum_index < digit_pos_to_extract:
      # if the exponential term is an integer and we mod it by the denominator
      # before dividing, only the integer part of the sum will change;
      # the fractional part will not
      _A           =    pow(
          16						,				digit_pos_to_extract - 1 - sum_index						,				__snake_case							)
    else:
      _A           =    pow(16						,				digit_pos_to_extract - 1 - sum_index							)
    total += exponential_term / denominator
  return total


if __name__ == "__main__":
    import doctest

    doctest.testmod()




import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()




def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case						,				__snake_case							)   -> Tuple:
  # Initialise PyTorch model
  _A           =    ElectraConfig.from_json_file(__snake_case							)
  print(F'''Building PyTorch model from configuration: {config}'''							)

  if discriminator_or_generator == "discriminator":
    _A           =    ElectraForPreTraining(__snake_case							)
  elif discriminator_or_generator == "generator":
    _A           =    ElectraForMaskedLM(__snake_case							)
  else:
    raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''							)

  # Load weights from tf checkpoint
  load_tf_weights_in_electra(
      __snake_case						,				__snake_case						,				__snake_case						,				discriminator_or_generator=__snake_case							)

  # Save pytorch-model
  print(F'''Save PyTorch model to {pytorch_dump_path}'''							)
  torch.save(model.state_dict()						,				__snake_case							)


if __name__ == "__main__":
    __lowerCamelCase  				=					argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
    )
    parser.add_argument(
        """--config_file""",
        default=None,
        type=str,
        required=True,
        help="""The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.""",
    )
    parser.add_argument(
        """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--discriminator_or_generator""",
        default=None,
        type=str,
        required=True,
        help=(
            """Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or """
            """'generator'."""
        ),
    )
    __lowerCamelCase  				=					parser.parse_args()
    convert_tf_checkpoint_to_pytorch(
        args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
    )