



import requests

try:
    from django.contrib.auth import authenticate, login
    from django.shortcuts import redirect, render
except ImportError:
    __lowerCamelCase  				=					__lowerCamelCase  				=					__lowerCamelCase  				=					__lowerCamelCase  				=					print




def     UpperCAmelCase__ (							__snake_case							)   -> int:
  _A           =    '''secretKey'''
  _A           =    '''https://www.google.com/recaptcha/api/siteverify'''

  # when method is not POST, direct user to login page
  if request.method != "POST":
    return render(lowerCamelCase__						,				'''login.html'''							)

  # from the frontend, get username, password, and client_key
  _A           =    request.POST.get('''username'''							)
  _A           =    request.POST.get('''password'''							)
  _A           =    request.POST.get('''g-recaptcha-response'''							)

  # post recaptcha response to Google's recaptcha api
  _A           =    requests.post(lowerCamelCase__						,				data={'''secret''': secret_key, '''response''': client_key}							)
  # if the recaptcha api verified our keys
  if response.json().get('''success'''						,				lowerCamelCase__							):
    # authenticate the user
    _A           =    authenticate(lowerCamelCase__						,				username=lowerCamelCase__						,				password=lowerCamelCase__							)
    if user_in_database:
      login(lowerCamelCase__						,				lowerCamelCase__							)
      return redirect('''/your-webpage'''							)
  return render(lowerCamelCase__						,				'''login.html'''							)




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
    )