





"""simple docstring"""
import argparse

import torch
from saprl.hub import distilhubert

from transformers import HubertConfig, HubertModel, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
__UpperCamelCase			:		Optional[Any]		    =   logging.get_logger(__name__)

__UpperCamelCase			:		Optional[Any]		    =   {
    '''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''',
    '''mask_emb''': '''masked_spec_embed''',
}

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  Tuple   ,			_UpperCAmelCase :  Any   ,			_UpperCAmelCase :  Any   ,			_UpperCAmelCase :  List[Any]   ,			_UpperCAmelCase :  int       ):
 for attribute in key.split('.'       ):
  lowerCAmelCase  							=      getattr(_UpperCAmelCase   ,			_UpperCAmelCase       )

 if weight_type is not None:
  lowerCAmelCase  							=      getattr(_UpperCAmelCase   ,			_UpperCAmelCase       ).shape
 else:
  lowerCAmelCase  							=      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  							=      value
 elif weight_type == "weight_g":
  lowerCAmelCase  							=      value
 elif weight_type == "weight_v":
  lowerCAmelCase  							=      value
 elif weight_type == "bias":
  lowerCAmelCase  							=      value
 else:
  lowerCAmelCase  							=      value

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

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  Optional[int]   ,			_UpperCAmelCase :  int       ):
 lowerCAmelCase  							=      []
 lowerCAmelCase  							=      fairseq_model.state_dict()

 lowerCAmelCase  							=      hf_model.feature_extractor

 for name, value in fairseq_dict.items():
  lowerCAmelCase  							=      False
  if "conv_layers" in name:
   load_conv_layer(
       _UpperCAmelCase   ,			_UpperCAmelCase   ,			_UpperCAmelCase   ,			_UpperCAmelCase   ,			hf_model.config.feat_extract_norm == 'group'   ,			)
   lowerCAmelCase  							=      True
  else:
   for key, mapped_key in MAPPING.items():
    lowerCAmelCase  							=      mapped_key

    if key in name:
     lowerCAmelCase  							=      True
     if "*" in mapped_key:
      lowerCAmelCase  							=      name.split(_UpperCAmelCase       )[0].split('.'       )[-2]
      lowerCAmelCase  							=      mapped_key.replace('*'   ,			_UpperCAmelCase       )
     if "weight_g" in name:
      lowerCAmelCase  							=      'weight_g'
     elif "weight_v" in name:
      lowerCAmelCase  							=      'weight_v'
     elif "weight" in name:
      lowerCAmelCase  							=      'weight'
     elif "bias" in name:
      lowerCAmelCase  							=      'bias'
     else:
      lowerCAmelCase  							=      None
     set_recursively(_UpperCAmelCase   ,			_UpperCAmelCase   ,			_UpperCAmelCase   ,			_UpperCAmelCase   ,			_UpperCAmelCase       )
    continue
  if not is_used:
   unused_weights.append(_UpperCAmelCase       )

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

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

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  int       ):
 lowerCAmelCase  							=      HubertConfig()
 lowerCAmelCase  							=      model.config

 lowerCAmelCase  							=      fs_config.activation_dropout
 lowerCAmelCase  							=      False
 lowerCAmelCase  							=      fs_config.attention_dropout
 lowerCAmelCase  							=      False
 lowerCAmelCase  							=      eval(fs_config.extractor_conv_feature_layers       )
 lowerCAmelCase  							=      [x[0] for x in conv_layers]
 lowerCAmelCase  							=      [x[1] for x in conv_layers]
 lowerCAmelCase  							=      [x[2] for x in conv_layers]
 lowerCAmelCase  							=      'gelu'
 lowerCAmelCase  							=      'layer' if fs_config.extractor_mode == 'layer_norm' else 'group'
 lowerCAmelCase  							=      False
 lowerCAmelCase  							=      0.0
 lowerCAmelCase  							=      0.0
 lowerCAmelCase  							=      fs_config.activation_fn
 lowerCAmelCase  							=      fs_config.dropout
 lowerCAmelCase  							=      fs_config.encoder_embed_dim
 lowerCAmelCase  							=      0.02
 lowerCAmelCase  							=      fs_config.encoder_ffn_embed_dim
 lowerCAmelCase  							=      1e-5
 lowerCAmelCase  							=      0.0
 lowerCAmelCase  							=      fs_config.encoder_attention_heads
 lowerCAmelCase  							=      fs_config.conv_pos_groups
 lowerCAmelCase  							=      fs_config.conv_pos
 lowerCAmelCase  							=      len(_UpperCAmelCase       )
 lowerCAmelCase  							=      fs_config.encoder_layers

 return config

@torch.no_grad()
def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  str   ,			_UpperCAmelCase :  Union[str, Any]=None       ):
 lowerCAmelCase  							=      distilhubert().model.model

 if config_path is not None:
  lowerCAmelCase  							=      HubertConfig.from_pretrained(_UpperCAmelCase       )
 else:
  lowerCAmelCase  							=      convert_config(_UpperCAmelCase       )
 lowerCAmelCase  							=      model.eval()

 lowerCAmelCase  							=      WavaVecaFeatureExtractor(
     feature_size=1   ,			sampling_rate=1_6000   ,			padding_value=0   ,			do_normalize=_UpperCAmelCase   ,			return_attention_mask=_UpperCAmelCase   ,			)
 lowerCAmelCase  							=      HubertModel(_UpperCAmelCase       )

 recursively_load_weights(_UpperCAmelCase   ,			_UpperCAmelCase       )

 feature_extractor.save_pretrained(_UpperCAmelCase       )
 hf_model.save_pretrained(_UpperCAmelCase       )


if __name__ == "__main__":
       __UpperCamelCase			:		List[Any]		    =   argparse.ArgumentParser()
       parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
       parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
       __UpperCamelCase			:		List[Any]		    =   parser.parse_args()
       convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)












"""simple docstring"""
import os
import sys
import time

from . import transposition_cipher as trans_cipher

def 						_SCREAMING_SNAKE_CASE       ():
 lowerCAmelCase  							=      'Prehistoric Men.txt'
 lowerCAmelCase  							=      'Output.txt'
 lowerCAmelCase  							=      int(input('Enter key: '       )       )
 lowerCAmelCase  							=      input('Encrypt/Decrypt [e/d]: '       )

 if not os.path.exists(_UpperCAmelCase       ):
  print(F'File {input_file} does not exist. Quitting...'       )
  sys.exit()
 if os.path.exists(_UpperCAmelCase       ):
  print(F'Overwrite {output_file}? [y/n]'       )
  lowerCAmelCase  							=      input('> '       )
  if not response.lower().startswith('y'       ):
   sys.exit()

 lowerCAmelCase  							=      time.time()
 if mode.lower().startswith('e'       ):
  with open(_UpperCAmelCase       ) as f:
   lowerCAmelCase  							=      f.read()
  lowerCAmelCase  							=      trans_cipher.encrypt_message(_UpperCAmelCase   ,			_UpperCAmelCase       )
 elif mode.lower().startswith('d'       ):
  with open(_UpperCAmelCase       ) as f:
   lowerCAmelCase  							=      f.read()
  lowerCAmelCase  							=      trans_cipher.decrypt_message(_UpperCAmelCase   ,			_UpperCAmelCase       )

 with open(_UpperCAmelCase   ,			'w'       ) as output_obj:
  output_obj.write(_UpperCAmelCase       )

 lowerCAmelCase  							=      round(time.time() - start_time   ,			2       )
 print(('Done (', total_time, 'seconds )')       )


if __name__ == "__main__":
       main()





