




'''simple docstring'''


import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    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       (      a_	:							Dict				,					a_	:							Dict				,					a_	:							List[Any]				,					a_	:							str				,					a_	:							Any			):






		for attribute in key.split('.'			):
				__a			=					getattr(a_				,					a_			)

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

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


def 						SCREAMING_SNAKE_CASE       (      a_	:							List[str]				,					a_	:							Union[str, Any]			):
		__a			=					[]
		__a			=					fairseq_model.state_dict()

		__a			=					hf_model.feature_extractor
		__a			=					hf_model.adapter

		for name, value in fairseq_dict.items():
				__a			=					False
				if "conv_layers" in name:
						load_conv_layer(
						    a_				,					a_				,					a_				,					a_				,					hf_model.config.feat_extract_norm == 'group'				,					)
						__a			=					True
				elif any(x in name for x in ['adaptor', 'w2v_encoder.proj.', 'w2v_proj_ln.']			):
						load_adapter(a_				,					a_				,					a_				,					a_			)
						__a			=					True
				else:
						for key, mapped_key in MAPPING.items():
								if key in name or key.split('w2v_model.'			)[-1] == name.split('.'			)[0]:
										__a			=					True
										if "*" in mapped_key:
												__a			=					name.split(a_			)[0].split('.'			)[-2]
												__a			=					mapped_key.replace('*'				,					a_			)
										if "weight_g" in name:
												__a			=					'''weight_g'''
										elif "weight_v" in name:
												__a			=					'''weight_v'''
										elif "bias" in name:
												__a			=					'''bias'''
										elif "weight" in name:
												__a			=					'''weight'''
										else:
												__a			=					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 						SCREAMING_SNAKE_CASE       (      a_	:							Any				,					a_	:							List[str]				,					a_	:							int				,					a_	:							str				,					a_	:							str			):
		__a			=					full_name.split('conv_layers.'			)[-1]
		__a			=					name.split('.'			)
		__a			=					int(items[0]			)
		__a			=					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."
						)
						__a			=					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."
						)
						__a			=					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."
						)
						__a			=					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."
						)
						__a			=					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       (      a_	:							int				,					a_	:							Optional[int]				,					a_	:							List[str]				,					a_	:							Optional[Any]			):
		__a			=					full_name.split('adaptor.'			)[-1]
		__a			=					name.split('.'			)

		if items[1].isdigit():
				__a			=					int(items[1]			)
		else:
				__a			=					None

		if "adaptor" not in full_name:
				if "proj_ln" in full_name:
						# has to be layer norm
						if "bias" in name:
								assert (
								    value.shape == adapter.proj_layer_norm.bias.data.shape
								), f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found."
								__a			=					value
								logger.info(f"Adapter proj layer norm bias was initialized from {full_name}."			)
						if "weight" in name:
								assert (
								    value.shape == adapter.proj_layer_norm.weight.data.shape
								), f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found."
								__a			=					value
				else:
						# has to be projection layer
						if "bias" in name:
								assert (
								    value.shape == adapter.proj.bias.data.shape
								), f"{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found."
								__a			=					value
								logger.info(f"Adapter proj layer bias was initialized from {full_name}."			)
						if "weight" in name:
								assert (
								    value.shape == adapter.proj.weight.data.shape
								), f"{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found."
								__a			=					value
								logger.info(f"Adapter proj layer weight was initialized from {full_name}."			)
		elif isinstance(a_				,					a_			):
				if "bias" in name:
						assert (
						    value.shape == adapter.layers[layer_id].conv.bias.data.shape
						), f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found."
						__a			=					value
						logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}."			)
				elif "weight" in name:
						assert (
						    value.shape == adapter.layers[layer_id].conv.weight.data.shape
						), f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found."
						__a			=					value
						logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}."			)
		else:
				unused_weights.append(a_			)


def 						SCREAMING_SNAKE_CASE       (      a_	:							Union[str, Any]			):
		__a			=					emb.weight.shape
		__a			=					nn.Linear(a_				,					a_				,					bias=a_			)
		__a			=					emb.weight.data
		return lin_layer


@torch.no_grad()
def 						SCREAMING_SNAKE_CASE       (      a_	:							str				,					a_	:							List[str]				,					a_	:							Tuple				,					a_	:							Any				,					a_	:							Union[str, Any]				,					a_	:							Any				,					a_	:							Dict				,					a_	:							Dict				,					a_	:							Union[str, Any]				,					a_	:							Optional[Any]				,					a_	:							Any				,					):
		__a			=					WavaVecaConfig.from_pretrained(
		    a_				,					add_adapter=a_				,					adapter_stride=a_				,					adapter_kernel_size=a_				,					use_auth_token=a_				,					output_hidden_size=a_				,					)
		__a			=					MBartConfig.from_pretrained(a_			)

		# load model
		__a			=					fairseq.checkpoint_utils.load_model_ensemble_and_task(
		    [checkpoint_path]				,					arg_overrides={
		        'config_yaml': config_yaml_path,
		        'data': '/'.join(dict_path.split('/'			)[:-1]			),
		        'w2v_path': checkpoint_path,
		        'load_pretrained_decoder_from': None,
		    }				,					)
		__a			=					model[0].eval()

		# load feature extractor
		__a			=					WavaVecaFeatureExtractor.from_pretrained(a_				,					use_auth_token=a_			)

		# set weights for wav2vec2 encoder
		__a			=					WavaVecaModel(a_			)

		recursively_load_weights_wavaveca(model.encoder				,					a_			)

		# load decoder weights
		__a			=					MBartForCausalLM(a_			)
		__a			=					hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()				,					strict=a_			)
		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}"			)

		__a			=					SpeechEncoderDecoderModel(encoder=a_				,					decoder=a_			)
		__a			=					False

		__a			=					MBartaaTokenizer(a_			)
		tokenizer.save_pretrained(a_			)

		__a			=					hf_wavavec.config.to_dict()
		__a			=					tokenizer.pad_token_id
		__a			=					tokenizer.bos_token_id
		__a			=					tokenizer.eos_token_id
		__a			=					'''mbart50'''
		__a			=					'''wav2vec2'''

		__a			=					tokenizer.eos_token_id
		__a			=					25_0004
		__a			=					tokenizer.eos_token_id

		__a			=					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("--config_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model")
		parser.add_argument(
		    "--encoder_config_path",
		    default="facebook/wav2vec2-xls-r-1b",
		    type=str,
		    help="Path to hf encoder wav2vec2 checkpoint config",
		)
		parser.add_argument(
		    "--decoder_config_path",
		    default="facebook/mbart-large-50-one-to-many-mmt",
		    type=str,
		    help="Path to hf decoder checkpoint config",
		)
		parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers")
		parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers")
		parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers")
		parser.add_argument("--encoder_output_dim", default=10_24, type=int, help="encoder output dim")
		parser.add_argument("--start_token_id", default=25_00_04, type=int, help="`decoder_start_token_id` of model config")

		UpperCAmelCase_ 		=      parser.parse_args()
		convert_wavaveca_checkpoint(
		    args.checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.dict_path,
		    args.config_yaml_path,
		    encoder_config_path=args.encoder_config_path,
		    decoder_config_path=args.decoder_config_path,
		    add_adapter=args.add_adapter,
		    adapter_kernel_size=args.adapter_kernel_size,
		    adapter_stride=args.adapter_stride,
		    decoder_start_token_id=args.start_token_id,
		    encoder_output_dim=args.encoder_output_dim,
		)









'''simple docstring'''


import os
from datetime import datetime as dt

from github import Github


UpperCAmelCase_ 		=      [
    "good first issue",
    "good second issue",
    "good difficult issue",
    "enhancement",
    "new pipeline/model",
    "new scheduler",
    "wip",
]


def 						SCREAMING_SNAKE_CASE       (      ):
  __a			=					Github(os.environ['GITHUB_TOKEN']			)
  __a			=					g.get_repo('huggingface/diffusers'			)
  __a			=					repo.get_issues(state='open'			)

  for issue in open_issues:
    __a			=					sorted(issue.get_comments()				,					key=lambda a_			: i.created_at				,					reverse=a_			)
    __a			=					comments[0] if len(a_			) > 0 else None
    if (
        last_comment is not None
        and last_comment.user.login == "github-actions[bot]"
        and (dt.utcnow() - issue.updated_at).days > 7
        and (dt.utcnow() - issue.created_at).days >= 30
        and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
    ):
      # Closes the issue after 7 days of inactivity since the Stalebot notification.
      issue.edit(state='closed'			)
    elif (
        "stale" in issue.get_labels()
        and last_comment is not None
        and last_comment.user.login != "github-actions[bot]"
    ):
      # Opens the issue if someone other than Stalebot commented.
      issue.edit(state='open'			)
      issue.remove_from_labels('stale'			)
    elif (
        (dt.utcnow() - issue.updated_at).days > 23
        and (dt.utcnow() - issue.created_at).days >= 30
        and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
    ):
      # Post a Stalebot notification after 23 days of inactivity.
      issue.create_comment(
          'This issue has been automatically marked as stale because it has not had '
          'recent activity. If you think this still needs to be addressed '
          'please comment on this thread.\n\nPlease note that issues that do not follow the '
          '[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) '
          'are likely to be ignored.'			)
      issue.add_to_labels('stale'			)


if __name__ == "__main__":
  main()



