'''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    _lowerCamelCase       ( lowerCamelCase_   :				List[Any]      ,	lowerCamelCase_   :				List[str]      ,	lowerCamelCase_   :				Any      ,	lowerCamelCase_   :				Dict  ):



     """simple docstring"""





     UpperCAmelCase_				:  Any  = ElectraConfig.from_json_file(lowerCamelCase_  )
     print(F'''Building PyTorch model from configuration: {config}'''  )

     if discriminator_or_generator == "discriminator":
          UpperCAmelCase_				:  Union[str, Any]  = ElectraForPreTraining(lowerCamelCase_  )
     elif discriminator_or_generator == "generator":
          UpperCAmelCase_				:  int  = ElectraForMaskedLM(lowerCamelCase_  )
     else:
          raise ValueError('The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''  )

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

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


if __name__ == "__main__":
 snake_case__	:     Tuple      =    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\'.'''
     ),
 )
 snake_case__	:     List[Any]      =    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 				a__			(					lowerCAmelCase						:							int		):






     '''simple docstring'''
     if number != int(lowerCAmelCase		):
          raise ValueError("factorial() only accepts integral values"		)
     if number < 0:
          raise ValueError("factorial() not defined for negative values"		)
     UpperCAmelCase__				:			int							=    1
     for i in range(1							,     number + 1		):
          value *= i
     return value



def 				a__			(					lowerCAmelCase						:							int		):






     '''simple docstring'''
     if not isinstance(lowerCAmelCase							,     lowerCAmelCase		):
          raise ValueError("factorial() only accepts integral values"		)
     if n < 0:
          raise ValueError("factorial() not defined for negative values"		)
     return 1 if n == 0 or n == 1 else n * factorial(n - 1		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    A__   :						Any 							=     int(input("""Enter a positive integer: """).strip() or 0)
    print(f"""factorial{n} is {factorial(n)}""")



