code: 
  
  
  """simple docstring"""
  
  
  
  
  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_   (  lowercase__   :Optional[Any], lowercase__   :Optional[int], lowercase__   :Any, lowercase__   :Any    ):
  			# Initialise PyTorch model
  			__lowerCamelCase        =			ElectraConfig.from_json_file(lowercase__    )
  			print(f'Building PyTorch model from configuration: {config}'    )
  
  			if discriminator_or_generator == "discriminator":
  						__lowerCamelCase        =			ElectraForPreTraining(lowercase__    )
  			elif discriminator_or_generator == "generator":
  						__lowerCamelCase        =			ElectraForMaskedLM(lowercase__    )
  			else:
  						raise ValueError("""The discriminator_or_generator argument should be either 'discriminator' or 'generator'"""    )
  
  			# Load weights from tf checkpoint
  			load_tf_weights_in_electra(
  			    lowercase__, lowercase__, lowercase__, discriminator_or_generator=lowercase__    )
  
  			# Save pytorch-model
  			print(f'Save PyTorch model to {pytorch_dump_path}'    )
  			torch.save(model.state_dict(), lowercase__    )
  
  
  if __name__ == "__main__":
  					__magic_name__	:   List[Any]          =							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\'.'
  					    ),
  					)
  					__magic_name__	:   Union[str, Any]          =							parser.parse_args()
  					convert_tf_checkpoint_to_pytorch(
  					    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
  					)
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :int = 13    ):
  			__lowerCamelCase        =			""""""
  			for c in s:
  						if "A" <= c <= "Z":
  									out += chr(ord("""A"""    ) + (ord(lowercase__    ) - ord("""A"""    ) + n) % 26    )
  						elif "a" <= c <= "z":
  									out += chr(ord("""a"""    ) + (ord(lowercase__    ) - ord("""a"""    ) + n) % 26    )
  						else:
  									out += c
  			return out
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			input("""Enter message: """    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Encryption:""", lowercase__    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Decryption: """, lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  					main()
  
  
  
  
  