
'''simple docstring'''
import argparse

import fairseq
import torch

from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging


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

lowerCAmelCase					:    int           = {
    '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',
    'encoder.layer_norm_for_extract': 'layer_norm_for_extract',
    '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',
    'label_embs_concat': 'label_embeddings_concat',
    'mask_emb': 'masked_spec_embed',
    'spk_proj': 'speaker_proj',
}
lowerCAmelCase					:    Dict           = [
    'lm_head',
    'quantizer.weight_proj',
    'quantizer.codevectors',
    'project_q',
    'project_hid',
    'label_embeddings_concat',
    'speaker_proj',
    'layer_norm_for_extract',
]







def 		A_(     A						:		Optional[Any]		,     A						:		Optional[int]		,     A						:		List[str]		,     A						:		Dict		,     A						:		Optional[int]):
							for attribute in key.split('.'):
														UpperCamelCase   			=     getattr(A		,     A)

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

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







def 		A_(     A						:		Tuple		,     A						:		List[str]):
							UpperCamelCase   			=     []
							UpperCamelCase   			=     fairseq_model.state_dict()

							UpperCamelCase   			=     hf_model.unispeech_sat.feature_extractor

							for name, value in fairseq_dict.items():
														UpperCamelCase   			=     False
														if "conv_layers" in name:
																					load_conv_layer(
																					    A		,     A		,     A		,     A		,     hf_model.config.feat_extract_norm == 'group'		,     )
																					UpperCamelCase   			=     True
														else:
																					for key, mapped_key in MAPPING.items():
																												UpperCamelCase   			=     'unispeech_sat.' + 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]:
																																			if "layer_norm_for_extract" in name and (".".join(name.split('.')[:-1]) != key):
																																										# special case since naming is very similar
																																										continue
																																			UpperCamelCase   			=     True
																																			if "*" in mapped_key:
																																										UpperCamelCase   			=     name.split(A)[0].split('.')[-2]
																																										UpperCamelCase   			=     mapped_key.replace('*'		,     A)
																																			if "weight_g" in name:
																																										UpperCamelCase   			=     'weight_g'
																																			elif "weight_v" in name:
																																										UpperCamelCase   			=     'weight_v'
																																			elif "bias" in name:
																																										UpperCamelCase   			=     'bias'
																																			elif "weight" in name:
																																										# TODO: don't match quantizer.weight_proj
																																										UpperCamelCase   			=     'weight'
																																			else:
																																										UpperCamelCase   			=     None
																																			set_recursively(A		,     A		,     A		,     A		,     A)
																												continue
														if not is_used:
																					unused_weights.append(A)

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







def 		A_(     A						:		List[Any]		,     A						:		str		,     A						:		int		,     A						:		str		,     A						:		str):
							UpperCamelCase   			=     full_name.split('conv_layers.')[-1]
							UpperCamelCase   			=     name.split('.')
							UpperCamelCase   			=     int(items[0])
							UpperCamelCase   			=     int(items[1])

							if type_id == 0:
														if "bias" in name:
																					if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
																												raise ValueError(
																												    f'''{full_name} has size {value.shape}, but'''
																												    f''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.''')
																					UpperCamelCase   			=     value
																					logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.''')
														elif "weight" in name:
																					if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
																												raise ValueError(
																												    f'''{full_name} has size {value.shape}, but'''
																												    f''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.''')
																					UpperCamelCase   			=     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:
																					if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
																												raise ValueError(
																												    f'''{full_name} has size {value.shape}, but'''
																												    f''' {feature_extractor[layer_id].layer_norm.bias.data.shape} was found.''')
																					UpperCamelCase   			=     value
																					logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''')
														elif "weight" in name:
																					if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
																												raise ValueError(
																												    f'''{full_name} has size {value.shape}, but'''
																												    f''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.''')
																					UpperCamelCase   			=     value
																					logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''')
							else:
														unused_weights.append(A)







@torch.no_grad()
def 		A_(     A						:		Union[str, Any]		,     A						:		Optional[Any]		,     A						:		Optional[int]=None		,     A						:		List[str]=None		,     A						:		Any=True):
							if config_path is not None:
														UpperCamelCase   			=     UniSpeechSatConfig.from_pretrained(A)
							else:
														UpperCamelCase   			=     UniSpeechSatConfig()

							UpperCamelCase   			=     ''

							if is_finetuned:
														UpperCamelCase   			=     UniSpeechSatForCTC(A)
							else:
														UpperCamelCase   			=     UniSpeechSatForPreTraining(A)

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

							recursively_load_weights(A		,     A)

							hf_wavavec.save_pretrained(A)


if __name__ == "__main__":
						lowerCAmelCase					:    Tuple           = 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'
						)
						lowerCAmelCase					:    List[str]           = parser.parse_args()
						convert_unispeech_sat_checkpoint(
						    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
						)






'''simple docstring'''
import sys
import webbrowser

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
						print('Googling.....')
						lowerCAmelCase					:    List[Any]           = 'https://www.google.com/search?q=' + ' '.join(sys.argv[1:])
						lowerCAmelCase					:    List[Any]           = requests.get(url, headers={'UserAgent': UserAgent().random})
						# res.raise_for_status()
						with open('project1a.html', 'wb') as out_file:  # only for knowing the class
												for data in res.iter_content(1_00_00):
																		out_file.write(data)
						lowerCAmelCase					:    Tuple           = BeautifulSoup(res.text, 'html.parser')
						lowerCAmelCase					:    List[Any]           = list(soup.select('.eZt8xd'))[:5]

						print(len(links))
						for link in links:
												if link.text == "Maps":
																		webbrowser.open(link.get('href'))
												else:
																		webbrowser.open(f"""https://google.com{link.get('href')}""")




