'''simple docstring'''

import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
__a: List[str]          =   logging.get_logger(__name__)

__a: Dict          =   {
    """post_extract_proj""": """feature_projection.projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """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""",
    """quantizer.weight_proj""": """quantizer.weight_proj""",
    """quantizer.vars""": """quantizer.codevectors""",
    """project_q""": """project_q""",
    """final_proj""": """project_hid""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}
__a: List[str]          =   [
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
]
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 for attribute in key.split('''.'''     ):
  lowercase__				:    Optional[int]  =					getattr(UpperCAmelCase		,     UpperCAmelCase     )

 if weight_type is not None:
  lowercase__				:    Dict  =					getattr(UpperCAmelCase		,     UpperCAmelCase     ).shape
 else:
  lowercase__				:    Any  =					hf_pointer.shape

 assert hf_shape == value.shape, (
     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__				:    Any  =					value
 elif weight_type == "weight_g":
  lowercase__				:    Any  =					value
 elif weight_type == "weight_v":
  lowercase__				:    int  =					value
 elif weight_type == "bias":
  lowercase__				:    Tuple  =					value
 else:
  lowercase__				:    List[Any]  =					value

 logger.info(F"""{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."""     )
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					[]
 lowercase__				:    List[str]  =					fairseq_model.state_dict()

 lowercase__				:    int  =					hf_model.feature_extractor

 # if encoder has different dim to decoder -> use proj_weight
 lowercase__				:    str  =					None

 for name, value in fairseq_dict.items():
  lowercase__				:    Tuple  =					False
  if "conv_layers" in name:
   load_conv_layer(
       UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     hf_model.config.feat_extract_norm == '''group'''		,     )
   lowercase__				:    Optional[int]  =					True
  elif name.split('''.'''     )[0] == "proj":
   lowercase__				:    List[Any]  =					fairseq_model.proj
   lowercase__				:    str  =					True
  else:
   for key, mapped_key in MAPPING.items():
    if key in name or key.split('''w2v_model.'''     )[-1] == name.split('''.'''     )[0]:
     lowercase__				:    Optional[int]  =					True
     if "*" in mapped_key:
      lowercase__				:    Tuple  =					name.split(UpperCAmelCase     )[0].split('''.'''     )[-2]
      lowercase__				:    int  =					mapped_key.replace('''*'''		,     UpperCAmelCase     )
     if "weight_g" in name:
      lowercase__				:    Optional[Any]  =					'''weight_g'''
     elif "weight_v" in name:
      lowercase__				:    str  =					'''weight_v'''
     elif "bias" in name:
      lowercase__				:    Any  =					'''bias'''
     elif "weight" in name:
      lowercase__				:    Optional[Any]  =					'''weight'''
     else:
      lowercase__				:    Tuple  =					None
     set_recursively(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )
    continue
  if not is_used:
   unused_weights.append(UpperCAmelCase     )

 logger.warning(F"""Unused weights: {unused_weights}"""     )

 return proj_weight
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					full_name.split('''conv_layers.'''     )[-1]
 lowercase__				:    Optional[Any]  =					name.split('''.'''     )
 lowercase__				:    Optional[int]  =					int(items[0]     )
 lowercase__				:    Union[str, Any]  =					int(items[1]     )

 if type_id == 0:
  if "bias" in name:
   assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
       F"""{full_name} has size {value.shape}, but"""
       F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""
   )
   lowercase__				:    int  =					value
   logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""     )
  elif "weight" in name:
   assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
       F"""{full_name} has size {value.shape}, but"""
       F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""
   )
   lowercase__				:    Any  =					value
   logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""     )
 elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
  if "bias" in name:
   assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
       F"""{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"""
       " found."
   )
   lowercase__				:    List[str]  =					value
   logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""     )
  elif "weight" in name:
   assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
       F"""{full_name} has size {value.shape}, but"""
       F""" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."""
   )
   lowercase__				:    Tuple  =					value
   logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""     )
 else:
  unused_weights.append(UpperCAmelCase     )
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__ ,							lowercase__				:    List[Any]  =					emb.weight.shape
 lowercase__				:    Dict  =					nn.Linear(UpperCAmelCase		,     UpperCAmelCase		,     bias=UpperCAmelCase     )
 lowercase__				:    Any  =					emb.weight.data
 return lin_layer
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 with open(UpperCAmelCase		,     '''r'''		,     encoding='''utf-8'''     ) as f:
  lowercase__				:    Optional[int]  =					f.readlines()
  lowercase__				:    List[Any]  =					[line.split(''' '''     )[0] for line in lines]

 lowercase__				:    Optional[int]  =					len(UpperCAmelCase     )

 lowercase__				:    List[Any]  =					{
     '''<s>''': 0,
     '''<pad>''': 1,
     '''</s>''': 2,
     '''<unk>''': 3,
 }

 vocab_dict.update(dict(zip(UpperCAmelCase		,     range(4		,     num_words + 4     )     )     )     )
 return vocab_dict
@torch.no_grad()
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     ):
 lowercase__				:    List[Any]  =					WavaVecaConfig.from_pretrained(UpperCAmelCase     )
 lowercase__				:    Optional[Any]  =					SpeechaTextaConfig.from_pretrained(
     UpperCAmelCase		,     vocab_size=UpperCAmelCase		,     decoder_layers=UpperCAmelCase		,     do_stable_layer_norm=UpperCAmelCase     )

 lowercase__				:    str  =					WavaVecaFeatureExtractor(
     feature_size=1		,     sampling_rate=1_6000		,     padding_value=0		,     do_normalize=UpperCAmelCase		,     return_attention_mask=UpperCAmelCase		,     )

 lowercase__ ,							lowercase__ ,							lowercase__				:    Tuple  =					fairseq.checkpoint_utils.load_model_ensemble_and_task(
     [checkpoint_path]		,     arg_overrides={'''data''': '''/'''.join(dict_path.split('''/'''     )[:-1]     )}     )
 lowercase__				:    Tuple  =					model[0].eval()

 # set weights for wav2vec2 encoder
 lowercase__				:    Optional[int]  =					WavaVecaModel(UpperCAmelCase     )
 lowercase__				:    Any  =					recursively_load_weights_wavaveca(model.encoder		,     UpperCAmelCase     )

 lowercase__				:    Any  =					SpeechaTextaForCausalLM(UpperCAmelCase     )
 lowercase__ ,							lowercase__				:    int  =					hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()		,     strict=UpperCAmelCase     )

 # set output linear layer
 unexpected_keys.remove('''embed_out'''     )
 lowercase__				:    Optional[int]  =					nn.Parameter(model.decoder.embed_out.detach()     )

 # layer norm is init to identity matrix so leaving it is fine
 logger.warning(F"""The following keys are missing when loading the decoder weights: {missing_keys}"""     )
 logger.warning(F"""The following keys are unexpected when loading the decoder weights: {unexpected_keys}"""     )

 lowercase__				:    List[Any]  =					SpeechEncoderDecoderModel(encoder=UpperCAmelCase		,     decoder=UpperCAmelCase     )
 lowercase__				:    Union[str, Any]  =					False

 # add projection layer
 lowercase__				:    Tuple  =					nn.Parameter(projection_layer.weight     )
 lowercase__				:    Optional[int]  =					nn.Parameter(projection_layer.bias     )

 lowercase__				:    Union[str, Any]  =					create_vocab_dict(UpperCAmelCase     )

 with open(os.path.join(UpperCAmelCase		,     '''vocab.json'''     )		,     '''w'''     ) as fp:
  json.dump(UpperCAmelCase		,     UpperCAmelCase     )

 lowercase__				:    str  =					SpeechaTextaTokenizer(os.path.join(UpperCAmelCase		,     '''vocab.json'''     )     )
 tokenizer.save_pretrained(UpperCAmelCase     )

 lowercase__				:    int  =					hf_wavavec.config.to_dict()
 lowercase__				:    int  =					tokenizer.pad_token_id
 lowercase__				:    Optional[int]  =					tokenizer.bos_token_id
 lowercase__				:    str  =					tokenizer.eos_token_id
 lowercase__				:    Optional[int]  =					'''speech_to_text_2'''
 lowercase__				:    Optional[int]  =					'''wav2vec2'''

 lowercase__				:    List[Any]  =					SpeechEncoderDecoderConfig.from_dict(UpperCAmelCase     )

 hf_wavavec.save_pretrained(UpperCAmelCase     )
 feature_extractor.save_pretrained(UpperCAmelCase     )


if __name__ == "__main__":
  __a: List[str]          =   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(
      """--encoder_config_path""",
      default="""facebook/wav2vec2-large-lv60""",
      type=str,
      help="""Path to hf encoder wav2vec2 checkpoint config""",
  )
  parser.add_argument(
      """--decoder_config_path""",
      default="""facebook/s2t-small-mustc-en-fr-st""",
      type=str,
      help="""Path to hf decoder s2t checkpoint config""",
  )
  parser.add_argument("""--vocab_size""", default=1_02_24, type=int, help="""Vocab size of decoder""")
  parser.add_argument("""--num_decoder_layers""", default=7, type=int, help="""Number of decoder layers""")

  __a: Any          =   parser.parse_args()
  convert_wavaveca_checkpoint(
      args.checkpoint_path,
      args.pytorch_dump_folder_path,
      args.dict_path,
      encoder_config_path=args.encoder_config_path,
      decoder_config_path=args.decoder_config_path,
      vocab_size=args.vocab_size,
      num_decoder_layers=args.num_decoder_layers,
  )


'''simple docstring'''

import unittest

from knapsack import knapsack as k



class 			UpperCAmelCase  (						unittest.TestCase					):





       '''simple docstring'''



       def _lowerCAmelCase(						self )  ->  Tuple:
        lowercase__				:    Optional[Any]  =					0
        lowercase__				:    Any  =					[0]
        lowercase__				:    List[Any]  =					[0]
        lowercase__				:    Optional[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   0 )

        lowercase__				:    List[str]  =					[60]
        lowercase__				:    List[str]  =					[10]
        lowercase__				:    List[str]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   0 )

       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Optional[Any]  =					3
        lowercase__				:    List[Any]  =					[1, 2, 3]
        lowercase__				:    Union[str, Any]  =					[3, 2, 1]
        lowercase__				:    List[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   5 )


       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    int  =					50
        lowercase__				:    Any  =					[60, 100, 120]
        lowercase__				:    int  =					[10, 20, 30]
        lowercase__				:    Optional[Any]  =					len(__lowerCAmelCase )
        self.assertEqual(k.knapsack(__lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )	,   220 )


if __name__ == "__main__":
  unittest.main()

