





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()
_UpperCAmelCase             =							logging.get_logger(__name__)

_UpperCAmelCase             =							{
    '''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''',
}
_UpperCAmelCase             =							[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:str   ,   SCREAMING_SNAKE_CASE		:Any   ,   SCREAMING_SNAKE_CASE		:Optional[Any]   ,   SCREAMING_SNAKE_CASE		:Union[str, Any]   )      ->   str:
 for attribute in key.split("""."""   ):
  __lowerCAmelCase					:	List[Any]      =       getattr(A_   ,   A_   )

 if weight_type is not None:
  __lowerCAmelCase					:	int      =       getattr(A_   ,   A_   ).shape
 else:
  __lowerCAmelCase					:	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":
  __lowerCAmelCase					:	List[Any]      =       value
 elif weight_type == "weight_g":
  __lowerCAmelCase					:	Optional[Any]      =       value
 elif weight_type == "weight_v":
  __lowerCAmelCase					:	List[str]      =       value
 elif weight_type == "bias":
  __lowerCAmelCase					:	str      =       value
 else:
  __lowerCAmelCase					:	str      =       value

 logger.info(F'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'''   )






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:List[str]   )      ->   Any:
 __lowerCAmelCase					:	List[str]      =       []
 __lowerCAmelCase					:	Optional[Any]      =       fairseq_model.state_dict()

 __lowerCAmelCase					:	Tuple      =       hf_model.feature_extractor

 # if encoder has different dim to decoder -> use proj_weight
 __lowerCAmelCase					:	Dict      =       None

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

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

 return proj_weight






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Union[str, Any]   ,   SCREAMING_SNAKE_CASE		:Union[str, Any]   ,   SCREAMING_SNAKE_CASE		:Dict   )      ->   Optional[int]:
 __lowerCAmelCase					:	Optional[int]      =       full_name.split("""conv_layers."""   )[-1]
 __lowerCAmelCase					:	str      =       name.split("""."""   )
 __lowerCAmelCase					:	Tuple      =       int(items[0]   )
 __lowerCAmelCase					:	Optional[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.'''
   )
   __lowerCAmelCase					:	Any      =       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.'''
   )
   __lowerCAmelCase					:	Optional[int]      =       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."
   )
   __lowerCAmelCase					:	Optional[int]      =       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.'''
   )
   __lowerCAmelCase					:	Any      =       value
   logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''   )
 else:
  unused_weights.append(A_   )






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:int   )      ->   List[str]:
 __lowerCAmelCase					:	Optional[Any]      =       emb.weight.shape
 __lowerCAmelCase					:	Optional[int]      =       nn.Linear(A_   ,   A_   ,   bias=A_   )
 __lowerCAmelCase					:	Optional[int]      =       emb.weight.data
 return lin_layer






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Any   )      ->   Any:
 with open(A_   ,   """r"""   ,   encoding="""utf-8"""   ) as f:
  __lowerCAmelCase					:	Dict      =       f.readlines()
  __lowerCAmelCase					:	Optional[Any]      =       [line.split(""" """   )[0] for line in lines]

 __lowerCAmelCase					:	Dict      =       len(A_   )

 __lowerCAmelCase					:	Optional[int]      =       {
     '''<s>''': 0,
     '''<pad>''': 1,
     '''</s>''': 2,
     '''<unk>''': 3,
 }

 vocab_dict.update(dict(zip(A_   ,   range(4   ,   num_words + 4   )   )   )   )
 return vocab_dict






@torch.no_grad()
def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Optional[Any]   ,   SCREAMING_SNAKE_CASE		:List[Any]   ,   SCREAMING_SNAKE_CASE		:Optional[int]   ,   SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Optional[Any]   ,   SCREAMING_SNAKE_CASE		:List[str]   ,   )      ->   List[Any]:
 __lowerCAmelCase					:	int      =       WavaVecaConfig.from_pretrained(A_   )
 __lowerCAmelCase					:	Any      =       SpeechaTextaConfig.from_pretrained(
     A_   ,   vocab_size=A_   ,   decoder_layers=A_   ,   do_stable_layer_norm=A_   )

 __lowerCAmelCase					:	str      =       WavaVecaFeatureExtractor(
     feature_size=1   ,   sampling_rate=16_000   ,   padding_value=0   ,   do_normalize=A_   ,   return_attention_mask=A_   ,   )

 __lowerCAmelCase					:	Union[str, Any]      =       fairseq.checkpoint_utils.load_model_ensemble_and_task(
     [checkpoint_path]   ,   arg_overrides={"""data""": """/""".join(dict_path.split("""/"""   )[:-1]   )}   )
 __lowerCAmelCase					:	List[str]      =       model[0].eval()

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

 __lowerCAmelCase					:	Tuple      =       SpeechaTextaForCausalLM(A_   )
 __lowerCAmelCase					:	Union[str, Any]      =       hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()   ,   strict=A_   )

 # set output linear layer
 unexpected_keys.remove("""embed_out"""   )
 __lowerCAmelCase					:	List[str]      =       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}'''   )

 __lowerCAmelCase					:	int      =       SpeechEncoderDecoderModel(encoder=A_   ,   decoder=A_   )
 __lowerCAmelCase					:	List[Any]      =       False

 # add projection layer
 __lowerCAmelCase					:	str      =       nn.Parameter(projection_layer.weight   )
 __lowerCAmelCase					:	List[Any]      =       nn.Parameter(projection_layer.bias   )

 __lowerCAmelCase					:	Optional[int]      =       create_vocab_dict(A_   )

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

 __lowerCAmelCase					:	Dict      =       SpeechaTextaTokenizer(os.path.join(A_   ,   """vocab.json"""   )   )
 tokenizer.save_pretrained(A_   )

 __lowerCAmelCase					:	str      =       hf_wavavec.config.to_dict()
 __lowerCAmelCase					:	Any      =       tokenizer.pad_token_id
 __lowerCAmelCase					:	Optional[Any]      =       tokenizer.bos_token_id
 __lowerCAmelCase					:	Tuple      =       tokenizer.eos_token_id
 __lowerCAmelCase					:	Optional[Any]      =       '''speech_to_text_2'''
 __lowerCAmelCase					:	Dict      =       '''wav2vec2'''

 __lowerCAmelCase					:	str      =       SpeechEncoderDecoderConfig.from_dict(A_   )

 hf_wavavec.save_pretrained(A_   )
 feature_extractor.save_pretrained(A_   )


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(
          '--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_0224, type=int, help='Vocab size of decoder')
      parser.add_argument('--num_decoder_layers', default=7, type=int, help='Number of decoder layers')

      _UpperCAmelCase             =							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,
      )






from math import isqrt






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:int   )      ->   list[int]:
 __lowerCAmelCase					:	Tuple      =       [True] * max_number
 for i in range(2   ,   isqrt(max_number - 1   ) + 1   ):
  if is_prime[i]:
   for j in range(i**2   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ):
    __lowerCAmelCase					:	Tuple      =       False

 return [i for i in range(2   ,   SCREAMING_SNAKE_CASE   ) if is_prime[i]]






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:int = 10**8   )      ->   int:
 __lowerCAmelCase					:	int      =       calculate_prime_numbers(max_number // 2   )

 __lowerCAmelCase					:	List[Any]      =       0
 __lowerCAmelCase					:	List[str]      =       0
 __lowerCAmelCase					:	List[Any]      =       len(SCREAMING_SNAKE_CASE   ) - 1
 while left <= right:
  while prime_numbers[left] * prime_numbers[right] >= max_number:
   right -= 1
  semiprimes_count += right - left + 1
  left += 1

 return semiprimes_count


if __name__ == "__main__":
      print(f'''{solution() = }''')