

def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase    ):
						if discount_rate < 0:
												raise ValueError("Discount rate cannot be negative"    )
						if not cash_flows:
												raise ValueError("Cash flows list cannot be empty"    )
						SCREAMING_SNAKE_CASE_: Any  		=       sum(
						    cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(_UpperCAmelCase    )    )
						return round(_UpperCAmelCase				,	ndigits=2    )


if __name__ == "__main__":
						import doctest

						doctest.testmod()













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

lowercase_					= {
    """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						(     __lowerCamelCase :    Dict					,       __lowerCamelCase :    Optional[int]					,       __lowerCamelCase :    int					,       __lowerCamelCase :    Union[str, Any]					,       __lowerCamelCase :    List[Any]    )						->Union[str, Any]:
    for attribute in key.split("""."""    ):
        _SCREAMING_SNAKE_CASE									=			getattr(__lowerCamelCase					,       __lowerCamelCase    )

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

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





def lowerCamelCase						(     __lowerCamelCase :    Optional[int]					,       __lowerCamelCase :    Optional[Any]					,       __lowerCamelCase :    List[Any]    )						->Any:
    _SCREAMING_SNAKE_CASE									=			[]
    _SCREAMING_SNAKE_CASE									=			fairseq_model.state_dict()

    _SCREAMING_SNAKE_CASE									=			hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

    for name, value in fairseq_dict.items():
        _SCREAMING_SNAKE_CASE									=			False
        if "conv_layers" in name:
            load_conv_layer(
                __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       hf_model.config.feat_extract_norm == """group"""					,       )
            _SCREAMING_SNAKE_CASE									=			True
        else:
            for key, mapped_key in MAPPING.items():
                _SCREAMING_SNAKE_CASE									=			"""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):
                    _SCREAMING_SNAKE_CASE									=			True
                    if "*" in mapped_key:
                        _SCREAMING_SNAKE_CASE									=			name.split(__lowerCamelCase    )[0].split("""."""    )[-2]
                        _SCREAMING_SNAKE_CASE									=			mapped_key.replace("""*"""					,       __lowerCamelCase    )
                    if "weight_g" in name:
                        _SCREAMING_SNAKE_CASE									=			"""weight_g"""
                    elif "weight_v" in name:
                        _SCREAMING_SNAKE_CASE									=			"""weight_v"""
                    elif "weight" in name:
                        _SCREAMING_SNAKE_CASE									=			"""weight"""
                    elif "bias" in name:
                        _SCREAMING_SNAKE_CASE									=			"""bias"""
                    else:
                        _SCREAMING_SNAKE_CASE									=			None
                    set_recursively(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase    )
                continue
        if not is_used:
            unused_weights.append(__lowerCamelCase    )

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





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





@torch.no_grad()
def lowerCamelCase						(     __lowerCamelCase :    str					,       __lowerCamelCase :    str					,       __lowerCamelCase :    List[Any]=None					,       __lowerCamelCase :    Optional[int]=None					,       __lowerCamelCase :    Union[str, Any]=True    )						->Optional[int]:
    if config_path is not None:
        _SCREAMING_SNAKE_CASE									=			HubertConfig.from_pretrained(__lowerCamelCase    )
    else:
        _SCREAMING_SNAKE_CASE									=			HubertConfig()

    if is_finetuned:
        if dict_path:
            _SCREAMING_SNAKE_CASE									=			Dictionary.load(__lowerCamelCase    )

            # important change bos & pad token id since CTC symbol is <pad> and
            # not <s> as in fairseq
            _SCREAMING_SNAKE_CASE									=			target_dict.pad_index
            _SCREAMING_SNAKE_CASE									=			target_dict.bos_index
            _SCREAMING_SNAKE_CASE									=			target_dict.eos_index
            _SCREAMING_SNAKE_CASE									=			len(target_dict.symbols    )
            _SCREAMING_SNAKE_CASE									=			os.path.join(__lowerCamelCase					,       """vocab.json"""    )
            if not os.path.isdir(__lowerCamelCase    ):
                logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(__lowerCamelCase    )    )
                return
            os.makedirs(__lowerCamelCase					,       exist_ok=__lowerCamelCase    )
            with open(__lowerCamelCase					,       """w"""					,       encoding="""utf-8"""    ) as vocab_handle:
                json.dump(target_dict.indices					,       __lowerCamelCase    )
            _SCREAMING_SNAKE_CASE									=			WavaVecaCTCTokenizer(
                __lowerCamelCase					,       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=__lowerCamelCase					,       )
            _SCREAMING_SNAKE_CASE									=			True if config.feat_extract_norm == """layer""" else False
            _SCREAMING_SNAKE_CASE									=			WavaVecaFeatureExtractor(
                feature_size=1					,       sampling_rate=1_6000					,       padding_value=0					,       do_normalize=__lowerCamelCase					,       return_attention_mask=__lowerCamelCase					,       )
            _SCREAMING_SNAKE_CASE									=			WavaVecaProcessor(feature_extractor=__lowerCamelCase					,       tokenizer=__lowerCamelCase    )
            processor.save_pretrained(__lowerCamelCase    )

        _SCREAMING_SNAKE_CASE									=			HubertForCTC(__lowerCamelCase    )
    else:
        _SCREAMING_SNAKE_CASE									=			HubertModel(__lowerCamelCase    )

    if is_finetuned:
        _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE									=			fairseq.checkpoint_utils.load_model_ensemble_and_task(
            [checkpoint_path]					,       arg_overrides={"""data""": """/""".join(dict_path.split("""/"""    )[:-1]    )}    )
    else:
        _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE									=			fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]    )

    _SCREAMING_SNAKE_CASE									=			model[0].eval()

    recursively_load_weights(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase    )

    hf_wavavec.save_pretrained(__lowerCamelCase    )


if __name__ == "__main__":
      lowercase_					= 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"""
      )
      lowercase_					= parser.parse_args()
      convert_hubert_checkpoint(
          args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
      )



