

'''simple docstring'''
import argparse
import pathlib

import fairseq
import torch
from fairseq.models.roberta import RobertaModel as FairseqRobertaModel
from fairseq.modules import TransformerSentenceEncoderLayer
from packaging import version

from transformers import RobertaConfig, RobertaForMaskedLM, RobertaForSequenceClassification
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('0.9.0'):
    raise Exception('requires fairseq >= 0.9.0')


logging.set_verbosity_info()
_snake_case     						=						logging.get_logger(__name__)

_snake_case     						=						'Hello world! cécé herlolip'







def       _A	(			snake_case	,							snake_case	,							snake_case  )    ->			Tuple:
   _lowercase    :   Optional[Any]      =     FairseqRobertaModel.from_pretrained(snake_case  )
   roberta.eval()  # disable dropout
   _lowercase    :   Optional[Any]      =     roberta.model.encoder.sentence_encoder
   _lowercase    :   int      =     RobertaConfig(
       vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings	,							hidden_size=roberta.args.encoder_embed_dim	,							num_hidden_layers=roberta.args.encoder_layers	,							num_attention_heads=roberta.args.encoder_attention_heads	,							intermediate_size=roberta.args.encoder_ffn_embed_dim	,							max_position_embeddings=5_14	,							type_vocab_size=1	,							layer_norm_eps=1E-5	,							)
   if classification_head:
      _lowercase    :   Optional[Any]      =     roberta.model.classification_heads["mnli"].out_proj.weight.shape[0]
   print("Our BERT config:"	,							snake_case  )

   _lowercase    :   Dict      =     RobertaForSequenceClassification(snake_case  ) if classification_head else RobertaForMaskedLM(snake_case  )
   model.eval()

   # Now let's copy all the weights.
   # Embeddings
   _lowercase    :   Optional[int]      =     roberta_sent_encoder.embed_tokens.weight
   _lowercase    :   Tuple      =     roberta_sent_encoder.embed_positions.weight
   _lowercase    :   Any      =     torch.zeros_like(
       model.roberta.embeddings.token_type_embeddings.weight  )  # just zero them out b/c RoBERTa doesn't use them.
   _lowercase    :   Dict      =     roberta_sent_encoder.emb_layer_norm.weight
   _lowercase    :   List[str]      =     roberta_sent_encoder.emb_layer_norm.bias

   for i in range(config.num_hidden_layers  ):
      # Encoder: start of layer
      _lowercase    :   Optional[int]      =     model.roberta.encoder.layer[i]
      _lowercase    :   Tuple      =     roberta_sent_encoder.layers[i]

      # self attention
      _lowercase    :   Union[str, Any]      =     layer.attention.self
      assert (
          roberta_layer.self_attn.k_proj.weight.data.shape
          == roberta_layer.self_attn.q_proj.weight.data.shape
          == roberta_layer.self_attn.v_proj.weight.data.shape
          == torch.Size((config.hidden_size, config.hidden_size)  )
      )

      _lowercase    :   Optional[int]      =     roberta_layer.self_attn.q_proj.weight
      _lowercase    :   List[str]      =     roberta_layer.self_attn.q_proj.bias
      _lowercase    :   Tuple      =     roberta_layer.self_attn.k_proj.weight
      _lowercase    :   List[str]      =     roberta_layer.self_attn.k_proj.bias
      _lowercase    :   Optional[int]      =     roberta_layer.self_attn.v_proj.weight
      _lowercase    :   Optional[int]      =     roberta_layer.self_attn.v_proj.bias

      # self-attention output
      _lowercase    :   Union[str, Any]      =     layer.attention.output
      assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape
      _lowercase    :   Optional[int]      =     roberta_layer.self_attn.out_proj.weight
      _lowercase    :   Union[str, Any]      =     roberta_layer.self_attn.out_proj.bias
      _lowercase    :   Optional[Any]      =     roberta_layer.self_attn_layer_norm.weight
      _lowercase    :   Union[str, Any]      =     roberta_layer.self_attn_layer_norm.bias

      # intermediate
      _lowercase    :   Optional[int]      =     layer.intermediate
      assert intermediate.dense.weight.shape == roberta_layer.fca.weight.shape
      _lowercase    :   Tuple      =     roberta_layer.fca.weight
      _lowercase    :   Optional[int]      =     roberta_layer.fca.bias

      # output
      _lowercase    :   str      =     layer.output
      assert bert_output.dense.weight.shape == roberta_layer.fca.weight.shape
      _lowercase    :   Tuple      =     roberta_layer.fca.weight
      _lowercase    :   Optional[int]      =     roberta_layer.fca.bias
      _lowercase    :   Dict      =     roberta_layer.final_layer_norm.weight
      _lowercase    :   Optional[Any]      =     roberta_layer.final_layer_norm.bias
      # end of layer

   if classification_head:
      _lowercase    :   Tuple      =     roberta.model.classification_heads["mnli"].dense.weight
      _lowercase    :   Optional[Any]      =     roberta.model.classification_heads["mnli"].dense.bias
      _lowercase    :   List[Any]      =     roberta.model.classification_heads["mnli"].out_proj.weight
      _lowercase    :   Any      =     roberta.model.classification_heads["mnli"].out_proj.bias
   else:
      # LM Head
      _lowercase    :   List[str]      =     roberta.model.encoder.lm_head.dense.weight
      _lowercase    :   str      =     roberta.model.encoder.lm_head.dense.bias
      _lowercase    :   Dict      =     roberta.model.encoder.lm_head.layer_norm.weight
      _lowercase    :   Union[str, Any]      =     roberta.model.encoder.lm_head.layer_norm.bias
      _lowercase    :   List[str]      =     roberta.model.encoder.lm_head.weight
      _lowercase    :   Dict      =     roberta.model.encoder.lm_head.bias

   # Let's check that we get the same results.
   _lowercase    :   List[str]      =     roberta.encode(snake_case  ).unsqueeze(0  )  # batch of size 1

   _lowercase    :   int      =     model(snake_case  )[0]
   if classification_head:
      _lowercase    :   int      =     roberta.model.classification_heads["mnli"](roberta.extract_features(snake_case  )  )
   else:
      _lowercase    :   Any      =     roberta.model(snake_case  )[0]
   print(our_output.shape	,							their_output.shape  )
   _lowercase    :   Union[str, Any]      =     torch.max(torch.abs(our_output - their_output  )  ).item()
   print(F'''max_absolute_diff = {max_absolute_diff}'''  )  # ~ 1e-7
   _lowercase    :   Union[str, Any]      =     torch.allclose(snake_case	,							snake_case	,							atol=1E-3  )
   print("Do both models output the same tensors?"	,							"🔥" if success else "💩"  )
   if not success:
      raise Exception("Something went wRoNg"  )

   pathlib.Path(snake_case  ).mkdir(parents=snake_case	,							exist_ok=snake_case  )
   print(F'''Saving model to {pytorch_dump_folder_path}'''  )
   model.save_pretrained(snake_case  )


if __name__ == "__main__":
    _snake_case     						=						argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--roberta_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
    )
    parser.add_argument(
        '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
    )
    parser.add_argument(
        '--classification_head', action='store_true', help='Whether to convert a final classification head.'
    )
    _snake_case     						=						parser.parse_args()
    convert_roberta_checkpoint_to_pytorch(
        args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
    )








'''simple docstring'''
import requests

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







def       _A	(			snake_case  )    ->			Any:
   # Enter your recaptcha secret key here
   _lowercase    :   Optional[Any]      =     "secretKey"
   _lowercase    :   Union[str, Any]      =     "https://www.google.com/recaptcha/api/siteverify"

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

   # from the frontend, get username, password, and client_key
   _lowercase    :   Optional[int]      =     request.POST.get("username"  )
   _lowercase    :   Tuple      =     request.POST.get("password"  )
   _lowercase    :   Tuple      =     request.POST.get("g-recaptcha-response"  )

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






