


import argparse
import os
from functools import reduce

import fairseq
import torch
from datasets import load_dataset

from transformers import WavaVecaProcessor, logging
from transformers.models.dataavec.configuration_dataavec_audio import DataaVecAudioConfig

# Copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_audio.py
from transformers.models.dataavec.dataavec_audio import DataaVecAudioModel as Dummy  # noqa: F401
from transformers.models.dataavec.modeling_dataavec_audio import DataaVecAudioForCTC, DataaVecAudioModel


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

UpperCAmelCase__     			=							{
    '''post_extract_proj''': '''feature_projection.projection''',
    '''models.0.layer_norm''': '''feature_projection.layer_norm''',
    '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''',
    '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''',
    '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''',
    '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''',
    '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''',
    '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''',
    '''fc2''': '''encoder.layers.*.feed_forward.output_dense''',
    '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''encoder.layer_norm''',
    '''w2v_model.layer_norm''': '''feature_projection.layer_norm''',
    '''w2v_encoder.proj''': '''lm_head''',
    '''mask_emb''': '''masked_spec_embed''',
}
UpperCAmelCase__     			=							[
    '''lm_head''',
]
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case		)  ->    List[str]:







 """simple docstring"""


 for attribute in key.split('''.'''		):
  _lowercase							   =getattr(__snake_case  ,		__snake_case		)

 if weight_type is not None:
  _lowercase							   =getattr(__snake_case  ,		__snake_case		).shape
 else:
  _lowercase							   =hf_pointer.shape

 if hf_shape != value.shape:
  raise ValueError(
      F"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
      F" {value.shape} for {full_name}"		)

 if weight_type == "weight":
  _lowercase							   =value
 elif weight_type == "weight_g":
  _lowercase							   =value
 elif weight_type == "weight_v":
  _lowercase							   =value
 elif weight_type == "bias":
  _lowercase							   =value
 else:
  _lowercase							   =value

 logger.info(F"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case		)  ->    int:







 """simple docstring"""


 _lowercase							   =[]
 _lowercase							   =fairseq_model.state_dict()

 if not is_headless:
  _lowercase							   =hf_model.dataavec_audio.feature_extractor
  _lowercase							   =hf_model.dataavec_audio.encoder.pos_conv_embed

 else:
  _lowercase							   =hf_model.feature_extractor
  _lowercase							   =hf_model.encoder.pos_conv_embed

 for name, value in fairseq_dict.items():
  _lowercase							   =False
  if "conv_layers" in name:
   load_conv_layer(
       __snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case  ,		)
   _lowercase							   =True
  elif "pos_conv" in name:
   load_pos_conv_layer(
       __snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case  ,		)
   _lowercase							   =True
  else:
   for key, mapped_key in MAPPING.items():
    if not is_headless:
     _lowercase							   ='''data2vec_audio.''' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
    if key in name or key.split('''w2v_model.'''		)[-1] == name.split('''.'''		)[0]:
     _lowercase							   =True
     if "*" in mapped_key:
      _lowercase							   =name.split(__snake_case		)[0].split('''.'''		)[-2]
      _lowercase							   =mapped_key.replace('''*'''  ,		__snake_case		)
     if "weight_g" in name:
      _lowercase							   ='''weight_g'''
     elif "weight_v" in name:
      _lowercase							   ='''weight_v'''
     elif "bias" in name:
      _lowercase							   ='''bias'''
     elif "weight" in name:
      # TODO: don't match quantizer.weight_proj
      _lowercase							   ='''weight'''
     else:
      _lowercase							   =None
     set_recursively(__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case		)
    continue
  if not is_used:
   unused_weights.append(__snake_case		)

 logger.warning(F"Unused weights: {unused_weights}"		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    List[str]:







 """simple docstring"""


 _lowercase							   =path.split('''.'''		)
 return reduce(__snake_case  ,		__snake_case  ,		__snake_case		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case		)  ->    Union[str, Any]:







 """simple docstring"""


 _lowercase							   =access_by_string(__snake_case  ,		__snake_case		)
 _lowercase							   =hf_weight.data

 if fsq_value.shape != hf_value.shape:
  raise ValueError(F"{full_name} has size {fsq_value.shape}, but {hf_value.shape} was found."		)
 _lowercase							   =fsq_value
 logger.info(F"{full_name} was correctly initialized from {hf_weight_path}."		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case		)  ->    List[Any]:







 """simple docstring"""


 _lowercase							   =full_name.split('''conv_layers.'''		)[-1]
 _lowercase							   =name.split('''.'''		)
 _lowercase							   =int(items[0]		)
 _lowercase							   =int(items[1]		)

 _lowercase							   =name.split('''.'''		)[-1]
 if type_id == 0:
  _lowercase							   ='''conv'''
 elif type_id == 2:
  _lowercase							   ='''layer_norm'''
 else:
  unused_weights.append(__snake_case		)
  return

 set_weights(__snake_case  ,		__snake_case  ,		__snake_case  ,		F"conv_layers.{layer_id}.{layer_type}.{weight_type}"		)
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case  ,		__snake_case		)  ->    Optional[int]:







 """simple docstring"""


 _lowercase							   =full_name.split('''pos_conv.'''		)[-1]
 _lowercase							   =name.split('''.'''		)
 _lowercase							   =int(items[0]		)
 _lowercase							   =int(items[1]		)

 _lowercase							   =name.split('''.'''		)[-1]
 if type_id != 0:
  unused_weights.append(__snake_case		)
  return
 else:
  _lowercase							   ='''conv'''

 set_weights(__snake_case  ,		__snake_case  ,		__snake_case  ,		F"layers.{layer_id}.{layer_type}.{weight_type}"		)
@torch.no_grad()
def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case=None  ,		__snake_case=None  ,		__snake_case=True		)  ->    Dict:







 """simple docstring"""


 if config_path is not None:
  _lowercase							   =DataaVecAudioConfig.from_pretrained(__snake_case		)
 else:
  _lowercase							   =DataaVecAudioConfig()

 if not is_finetuned:
  # Modify final_proj layer name
  _lowercase							   =DataaVecAudioModel(__snake_case		)
  _lowercase							   =os.path.dirname(__snake_case		)

  _lowercase							   =torch.load(__snake_case		)
  _lowercase							   =state_dict['''model'''].pop('''final_proj.0.weight'''		)
  _lowercase							   =state_dict['''model'''].pop('''final_proj.0.bias'''		)
  _lowercase							   =os.path.join(__snake_case  ,		'''converted.pt'''		)
  torch.save(__snake_case  ,		__snake_case		)
 else:
  _lowercase							   =DataaVecAudioForCTC(__snake_case		)
  _lowercase							   =checkpoint_path

 def load_dataavec(__snake_case		):
  _lowercase   ,					_lowercase   ,					_lowercase							   =fairseq.checkpoint_utils.load_model_ensemble_and_task([path]		)
  return model[0].eval()

 _lowercase							   =load_dataavec(__snake_case		)

 recursively_load_weights(__snake_case  ,		__snake_case  ,		not is_finetuned		)

 _lowercase							   =WavaVecaProcessor.from_pretrained('''facebook/wav2vec2-large-lv60'''		)

 _lowercase							   =load_dataset('''patrickvonplaten/librispeech_asr_dummy'''  ,		'''clean'''  ,		split='''validation'''		)
 _lowercase							   =[x['''array'''] for x in ds[:4]['''audio''']]

 _lowercase							   =processor(__snake_case  ,		return_tensors='''pt'''  ,		padding=__snake_case		)

 _lowercase							   =inputs.input_values
 _lowercase							   =inputs.attention_mask
 #    input_values = inputs.input_values[:, :-1]
 #    attention_mask = inputs.attention_mask[:, :-1]

 hf_wavavec.eval()
 model.eval()
 if is_finetuned:
  _lowercase							   =model(source=__snake_case  ,		padding_mask=(1 - attention_mask)  ,		mask=__snake_case  ,		features_only=__snake_case		)[
      '''encoder_out'''
  ].transpose(0  ,		1		)
  _lowercase							   =hf_wavavec(__snake_case  ,		attention_mask=__snake_case		)['''logits''']

  _lowercase							   =torch.argmax(__snake_case  ,		dim=-1		)
  _lowercase							   =processor.batch_decode(__snake_case		)

  print(F"Expected Output: {ds[:4]['text']}, Pred: {output_string}"		)
 else:
  _lowercase							   =model(source=__snake_case  ,		padding_mask=(1 - attention_mask)  ,		mask=__snake_case  ,		features_only=__snake_case		)[
      '''layer_results'''
  ][-1][0].transpose(0  ,		1		)
  _lowercase							   =hf_wavavec(__snake_case  ,		attention_mask=__snake_case		)['''last_hidden_state''']

 print(our_output.shape  ,		their_output.shape		)
 _lowercase							   =torch.max(torch.abs(our_output - their_output		)		).item()
 print(F"max_absolute_diff = {max_absolute_diff}"		)  # ~ 1e-7
 _lowercase							   =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'''		)

 hf_wavavec.save_pretrained(__snake_case		)

 if is_finetuned:
  processor.save_pretrained(__snake_case		)
 else:
  processor.feature_extractor.save_pretrained(__snake_case		)


if __name__ == "__main__":
  UpperCAmelCase__     			=							argparse.ArgumentParser()
  parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
  parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
  parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''')
  parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
  parser.add_argument(
      '''--not_finetuned''', action='''store_true''', help='''Whether the model to convert is a fine-tuned model or not'''
  )
  UpperCAmelCase__     			=							parser.parse_args()
  convert_wavaveca_checkpoint(
      args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
  )





import requests

try:
  from django.contrib.auth import authenticate, login
  from django.shortcuts import redirect, render
except ImportError:
  UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							print
def        UpperCAmelCase_      (							__snake_case		)  ->    List[str]:







 """simple docstring"""


 _lowercase							   ='''secretKey'''
 _lowercase							   ='''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							   =request.POST.get('''username'''		)
 _lowercase							   =request.POST.get('''password'''		)
 _lowercase							   =request.POST.get('''g-recaptcha-response'''		)

 # post recaptcha response to Google's recaptcha api
 _lowercase							   =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							   =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'''		)

