
"""simple docstring"""



import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    HubertConfig,
    HubertForCTC,
    HubertModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    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',
    'w2v_encoder.proj': 'lm_head',
    'mask_emb': 'masked_spec_embed',
}
def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case    ,_snake_case    ,_snake_case ):
    for attribute in key.split('.' ):
        UpperCAmelCase__	:      Union[str, Any]     							=					getattr(_snake_case    ,_snake_case )

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

    logger.info(F'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.''' )
def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case ):
    UpperCAmelCase__	:      Dict     							=					[]
    UpperCAmelCase__	:      Optional[Any]     							=					fairseq_model.state_dict()

    UpperCAmelCase__	:      List[str]     							=					hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

    for name, value in fairseq_dict.items():
        UpperCAmelCase__	:      Any     							=					False
        if "conv_layers" in name:
            load_conv_layer(
                _snake_case    ,_snake_case    ,_snake_case    ,_snake_case    ,hf_model.config.feat_extract_norm == 'group'    ,)
            UpperCAmelCase__	:      List[str]     							=					True
        else:
            for key, mapped_key in MAPPING.items():
                UpperCAmelCase__	:      Optional[int]     							=					'hubert.' + mapped_key if (is_finetuned and mapped_key != 'lm_head') else mapped_key

                if key in name or (key.split('w2v_model.' )[-1] == name.split('.' )[0] and not is_finetuned):
                    UpperCAmelCase__	:      str     							=					True
                    if "*" in mapped_key:
                        UpperCAmelCase__	:      Union[str, Any]     							=					name.split(_snake_case )[0].split('.' )[-2]
                        UpperCAmelCase__	:      Optional[Any]     							=					mapped_key.replace('*'    ,_snake_case )
                    if "weight_g" in name:
                        UpperCAmelCase__	:      str     							=					'weight_g'
                    elif "weight_v" in name:
                        UpperCAmelCase__	:      str     							=					'weight_v'
                    elif "weight" in name:
                        UpperCAmelCase__	:      int     							=					'weight'
                    elif "bias" in name:
                        UpperCAmelCase__	:      Tuple     							=					'bias'
                    else:
                        UpperCAmelCase__	:      Union[str, Any]     							=					None
                    set_recursively(_snake_case    ,_snake_case    ,_snake_case    ,_snake_case    ,_snake_case )
                continue
        if not is_used:
            unused_weights.append(_snake_case )

    logger.warning(F'''Unused weights: {unused_weights}''' )
def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case    ,_snake_case    ,_snake_case ):
    UpperCAmelCase__	:      Any     							=					full_name.split('conv_layers.' )[-1]
    UpperCAmelCase__	:      Union[str, Any]     							=					name.split('.' )
    UpperCAmelCase__	:      Optional[int]     							=					int(items[0] )
    UpperCAmelCase__	:      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.'''
            )
            UpperCAmelCase__	:      str     							=					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.'''
            )
            UpperCAmelCase__	:      Dict     							=					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."
            )
            UpperCAmelCase__	:      Tuple     							=					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.'''
            )
            UpperCAmelCase__	:      Dict     							=					value
            logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' )
    else:
        unused_weights.append(_snake_case )
@torch.no_grad()
def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case=None    ,_snake_case=None    ,_snake_case=True ):
    if config_path is not None:
        UpperCAmelCase__	:      List[Any]     							=					HubertConfig.from_pretrained(_snake_case )
    else:
        UpperCAmelCase__	:      Optional[int]     							=					HubertConfig()

    if is_finetuned:
        if dict_path:
            UpperCAmelCase__	:      Optional[Any]     							=					Dictionary.load(_snake_case )

            # important change bos & pad token id since CTC symbol is <pad> and
            # not <s> as in fairseq
            UpperCAmelCase__	:      Any     							=					target_dict.pad_index
            UpperCAmelCase__	:      Dict     							=					target_dict.bos_index
            UpperCAmelCase__	:      Union[str, Any]     							=					target_dict.eos_index
            UpperCAmelCase__	:      Tuple     							=					len(target_dict.symbols )
            UpperCAmelCase__	:      List[Any]     							=					os.path.join(_snake_case    ,'vocab.json' )
            if not os.path.isdir(_snake_case ):
                logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(_snake_case ) )
                return
            os.makedirs(_snake_case    ,exist_ok=_snake_case )
            with open(_snake_case    ,'w'    ,encoding='utf-8' ) as vocab_handle:
                json.dump(target_dict.indices    ,_snake_case )
            UpperCAmelCase__	:      List[Any]     							=					WavaVecaCTCTokenizer(
                _snake_case    ,unk_token=target_dict.unk_word    ,pad_token=target_dict.pad_word    ,bos_token=target_dict.bos_word    ,eos_token=target_dict.eos_word    ,word_delimiter_token='|'    ,do_lower_case=_snake_case    ,)
            UpperCAmelCase__	:      Tuple     							=					True if config.feat_extract_norm == 'layer' else False
            UpperCAmelCase__	:      Tuple     							=					WavaVecaFeatureExtractor(
                feature_size=1    ,sampling_rate=16000    ,padding_value=0    ,do_normalize=_snake_case    ,return_attention_mask=_snake_case    ,)
            UpperCAmelCase__	:      List[str]     							=					WavaVecaProcessor(feature_extractor=_snake_case    ,tokenizer=_snake_case )
            processor.save_pretrained(_snake_case )

        UpperCAmelCase__	:      Union[str, Any]     							=					HubertForCTC(_snake_case )
    else:
        UpperCAmelCase__	:      str     							=					HubertModel(_snake_case )

    if is_finetuned:
        UpperCAmelCase__							,							UpperCAmelCase__							,							UpperCAmelCase__	:      Dict     							=					fairseq.checkpoint_utils.load_model_ensemble_and_task(
            [checkpoint_path]    ,arg_overrides={'data': '/'.join(dict_path.split('/' )[:-1] )} )
    else:
        UpperCAmelCase__							,							UpperCAmelCase__							,							UpperCAmelCase__	:      Optional[int]     							=					fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] )

    UpperCAmelCase__	:      Optional[Any]     							=					model[0].eval()

    recursively_load_weights(_snake_case    ,_snake_case    ,_snake_case )

    hf_wavavec.save_pretrained(_snake_case )


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_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'
    )
    UpperCamelCase__          =	parser.parse_args()
    convert_hubert_checkpoint(
        args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
    )



"""simple docstring"""



from itertools import permutations
def 					lowerCamelCase   (     _snake_case ):
    if num[3] % 2 != 0:
        return False

    if (num[2] + num[3] + num[4]) % 3 != 0:
        return False

    if num[5] % 5 != 0:
        return False

    UpperCAmelCase__	:      List[str]     							=					[7, 11, 13, 17]
    for i, test in enumerate(_snake_case ):
        if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
            return False
    return True
def 					lowerCamelCase   (     _snake_case = 10 ):
    return sum(
        int(''.join(map(_snake_case    ,_snake_case ) ) )
        for num in permutations(range(_snake_case ) )
        if is_substring_divisible(_snake_case ) )


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

