





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      A__				(       SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__)  ->       int:
  # Initialise PyTorch model
  __snake_case:		List[Any]					    =		ElectraConfig.from_json_file(SCREAMING_SNAKE_CASE__)
  print(F'''Building PyTorch model from configuration: {config}''')

  if discriminator_or_generator == "discriminator":
    __snake_case:		Optional[Any]					    =		ElectraForPreTraining(SCREAMING_SNAKE_CASE__)
  elif discriminator_or_generator == "generator":
    __snake_case:		List[Any]					    =		ElectraForMaskedLM(SCREAMING_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(
      SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__   ,   SCREAMING_SNAKE_CASE__   ,   discriminator_or_generator=SCREAMING_SNAKE_CASE__)

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


if __name__ == "__main__":
      __UpperCAmelCase			:  List[str]										=				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\'."
          ),
      )
      __UpperCAmelCase			:  Tuple										=				parser.parse_args()
      convert_tf_checkpoint_to_pytorch(
          args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
      )














'''simple docstring'''







def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase = 13 ) ->			str:
							lowerCamelCase__   :      Dict			    =			""""""
							for c in s:
														if "A" <= c <= "Z":
																					out += chr(ord("""A""" ) + (ord(UpperCamelCase ) - ord("""A""" ) + n) % 26 )
														elif "a" <= c <= "z":
																					out += chr(ord("""a""" ) + (ord(UpperCamelCase ) - ord("""a""" ) + n) % 26 )
														else:
																					out += c
							return out





def 					SCREAMING_SNAKE_CASE_			() ->			None:
							lowerCamelCase__   :      Dict			    =			input("""Enter message: """ )

							lowerCamelCase__   :      str			    =			dencrypt(UpperCamelCase							,     13 )
							print("""Encryption:"""							,     UpperCamelCase )

							lowerCamelCase__   :      List[str]			    =			dencrypt(UpperCamelCase							,     13 )
							print("""Decryption: """							,     UpperCamelCase )


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			main()

