






'''simple docstring'''

import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
UpperCamelCase							=logging.get_logger("transformers.models.encodec")

UpperCamelCase							={
    "quantizer.vq.layers.*._codebook.inited": "quantizer.layers.*.codebook.inited",
    "quantizer.vq.layers.*._codebook.cluster_size": "quantizer.layers.*.codebook.cluster_size",
    "quantizer.vq.layers.*._codebook.embed": "quantizer.layers.*.codebook.embed",
    "quantizer.vq.layers.*._codebook.embed_avg": "quantizer.layers.*.codebook.embed_avg",
}
UpperCamelCase							={
    "encoder.model.0.conv.conv": "encoder.layers.0.conv",
    "encoder.model.1.block.1.conv.conv": "encoder.layers.1.block.1.conv",
    "encoder.model.1.block.3.conv.conv": "encoder.layers.1.block.3.conv",
    "encoder.model.1.shortcut.conv.conv": "encoder.layers.1.shortcut.conv",
    "encoder.model.3.conv.conv": "encoder.layers.3.conv",
    "encoder.model.4.block.1.conv.conv": "encoder.layers.4.block.1.conv",
    "encoder.model.4.block.3.conv.conv": "encoder.layers.4.block.3.conv",
    "encoder.model.4.shortcut.conv.conv": "encoder.layers.4.shortcut.conv",
    "encoder.model.6.conv.conv": "encoder.layers.6.conv",
    "encoder.model.7.block.1.conv.conv": "encoder.layers.7.block.1.conv",
    "encoder.model.7.block.3.conv.conv": "encoder.layers.7.block.3.conv",
    "encoder.model.7.shortcut.conv.conv": "encoder.layers.7.shortcut.conv",
    "encoder.model.9.conv.conv": "encoder.layers.9.conv",
    "encoder.model.10.block.1.conv.conv": "encoder.layers.10.block.1.conv",
    "encoder.model.10.block.3.conv.conv": "encoder.layers.10.block.3.conv",
    "encoder.model.10.shortcut.conv.conv": "encoder.layers.10.shortcut.conv",
    "encoder.model.12.conv.conv": "encoder.layers.12.conv",
    "encoder.model.13.lstm": "encoder.layers.13.lstm",
    "encoder.model.15.conv.conv": "encoder.layers.15.conv",
}
UpperCamelCase							={
    "encoder.model.0.conv.norm": "encoder.layers.0.norm",
    "encoder.model.1.block.1.conv.norm": "encoder.layers.1.block.1.norm",
    "encoder.model.1.block.3.conv.norm": "encoder.layers.1.block.3.norm",
    "encoder.model.1.shortcut.conv.norm": "encoder.layers.1.shortcut.norm",
    "encoder.model.3.conv.norm": "encoder.layers.3.norm",
    "encoder.model.4.block.1.conv.norm": "encoder.layers.4.block.1.norm",
    "encoder.model.4.block.3.conv.norm": "encoder.layers.4.block.3.norm",
    "encoder.model.4.shortcut.conv.norm": "encoder.layers.4.shortcut.norm",
    "encoder.model.6.conv.norm": "encoder.layers.6.norm",
    "encoder.model.7.block.1.conv.norm": "encoder.layers.7.block.1.norm",
    "encoder.model.7.block.3.conv.norm": "encoder.layers.7.block.3.norm",
    "encoder.model.7.shortcut.conv.norm": "encoder.layers.7.shortcut.norm",
    "encoder.model.9.conv.norm": "encoder.layers.9.norm",
    "encoder.model.10.block.1.conv.norm": "encoder.layers.10.block.1.norm",
    "encoder.model.10.block.3.conv.norm": "encoder.layers.10.block.3.norm",
    "encoder.model.10.shortcut.conv.norm": "encoder.layers.10.shortcut.norm",
    "encoder.model.12.conv.norm": "encoder.layers.12.norm",
    "encoder.model.15.conv.norm": "encoder.layers.15.norm",
}
UpperCamelCase							={
    "decoder.model.0.conv.conv": "decoder.layers.0.conv",
    "decoder.model.1.lstm": "decoder.layers.1.lstm",
    "decoder.model.3.convtr.convtr": "decoder.layers.3.conv",
    "decoder.model.4.block.1.conv.conv": "decoder.layers.4.block.1.conv",
    "decoder.model.4.block.3.conv.conv": "decoder.layers.4.block.3.conv",
    "decoder.model.4.shortcut.conv.conv": "decoder.layers.4.shortcut.conv",
    "decoder.model.6.convtr.convtr": "decoder.layers.6.conv",
    "decoder.model.7.block.1.conv.conv": "decoder.layers.7.block.1.conv",
    "decoder.model.7.block.3.conv.conv": "decoder.layers.7.block.3.conv",
    "decoder.model.7.shortcut.conv.conv": "decoder.layers.7.shortcut.conv",
    "decoder.model.9.convtr.convtr": "decoder.layers.9.conv",
    "decoder.model.10.block.1.conv.conv": "decoder.layers.10.block.1.conv",
    "decoder.model.10.block.3.conv.conv": "decoder.layers.10.block.3.conv",
    "decoder.model.10.shortcut.conv.conv": "decoder.layers.10.shortcut.conv",
    "decoder.model.12.convtr.convtr": "decoder.layers.12.conv",
    "decoder.model.13.block.1.conv.conv": "decoder.layers.13.block.1.conv",
    "decoder.model.13.block.3.conv.conv": "decoder.layers.13.block.3.conv",
    "decoder.model.13.shortcut.conv.conv": "decoder.layers.13.shortcut.conv",
    "decoder.model.15.conv.conv": "decoder.layers.15.conv",
}
UpperCamelCase							={
    "decoder.model.0.conv.norm": "decoder.layers.0.norm",
    "decoder.model.3.convtr.norm": "decoder.layers.3.norm",
    "decoder.model.4.block.1.conv.norm": "decoder.layers.4.block.1.norm",
    "decoder.model.4.block.3.conv.norm": "decoder.layers.4.block.3.norm",
    "decoder.model.4.shortcut.conv.norm": "decoder.layers.4.shortcut.norm",
    "decoder.model.6.convtr.norm": "decoder.layers.6.norm",
    "decoder.model.7.block.1.conv.norm": "decoder.layers.7.block.1.norm",
    "decoder.model.7.block.3.conv.norm": "decoder.layers.7.block.3.norm",
    "decoder.model.7.shortcut.conv.norm": "decoder.layers.7.shortcut.norm",
    "decoder.model.9.convtr.norm": "decoder.layers.9.norm",
    "decoder.model.10.block.1.conv.norm": "decoder.layers.10.block.1.norm",
    "decoder.model.10.block.3.conv.norm": "decoder.layers.10.block.3.norm",
    "decoder.model.10.shortcut.conv.norm": "decoder.layers.10.shortcut.norm",
    "decoder.model.12.convtr.norm": "decoder.layers.12.norm",
    "decoder.model.13.block.1.conv.norm": "decoder.layers.13.block.1.norm",
    "decoder.model.13.block.3.conv.norm": "decoder.layers.13.block.3.norm",
    "decoder.model.13.shortcut.conv.norm": "decoder.layers.13.shortcut.norm",
    "decoder.model.15.conv.norm": "decoder.layers.15.norm",
}
UpperCamelCase							={
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
UpperCamelCase							={
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
UpperCamelCase							=[]
UpperCamelCase							=[]



def 							snake_case					(     a_							: str    ,   a_							: List[Any]    ,   a_							: Optional[Any]    ,   a_							: Optional[Any]    ,   a_							: Optional[Any]	)       ->				Optional[Any]:





      """simple docstring"""

      for attribute in key.split("""."""	):
            UpperCamelCase_				:   int					    =							getattr(a_    ,   a_	)

      if weight_type is not None:
            UpperCamelCase_				:   int					    =							getattr(a_    ,   a_	).shape
      else:
            UpperCamelCase_				:   int					    =							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_				:   int					    =							value
      elif weight_type == "weight_g":
            UpperCamelCase_				:   str					    =							value
      elif weight_type == "weight_v":
            UpperCamelCase_				:   Any					    =							value
      elif weight_type == "bias":
            UpperCamelCase_				:   int					    =							value
      elif weight_type == "running_mean":
            UpperCamelCase_				:   Tuple					    =							value
      elif weight_type == "running_var":
            UpperCamelCase_				:   Dict					    =							value
      elif weight_type == "num_batches_tracked":
            UpperCamelCase_				:   Any					    =							value
      elif weight_type == "weight_ih_l0":
            UpperCamelCase_				:   Union[str, Any]					    =							value
      elif weight_type == "weight_hh_l0":
            UpperCamelCase_				:   List[str]					    =							value
      elif weight_type == "bias_ih_l0":
            UpperCamelCase_				:   Dict					    =							value
      elif weight_type == "bias_hh_l0":
            UpperCamelCase_				:   Union[str, Any]					    =							value
      elif weight_type == "weight_ih_l1":
            UpperCamelCase_				:   List[Any]					    =							value
      elif weight_type == "weight_hh_l1":
            UpperCamelCase_				:   str					    =							value
      elif weight_type == "bias_ih_l1":
            UpperCamelCase_				:   Tuple					    =							value
      elif weight_type == "bias_hh_l1":
            UpperCamelCase_				:   Union[str, Any]					    =							value
      else:
            UpperCamelCase_				:   str					    =							value

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



def 							snake_case					(     a_							: int    ,   a_							: Optional[Any]	)       ->				List[Any]:





      """simple docstring"""

      for key in ignore_keys:
            if key.endswith(""".*"""	):
                  if name.startswith(key[:-1]	):
                        return True
            elif ".*." in key:
                  UpperCamelCase_    ,			UpperCamelCase_				:   str					    =							key.split(""".*."""	)
                  if prefix in name and suffix in name:
                        return True
            elif key in name:
                  return True
      return False



def 							snake_case					(     a_							: Any    ,   a_							: Optional[Any]    ,   a_							: Dict	)       ->				Tuple:





      """simple docstring"""

      UpperCamelCase_				:   List[str]					    =							[]

      if model_name == "encodec_24khz" or "encodec_32khz":
            UpperCamelCase_				:   Dict					    =							MAPPING_24K
      elif model_name == "encodec_48khz":
            UpperCamelCase_				:   Optional[Any]					    =							MAPPING_48K
      else:
            raise ValueError(f"Unsupported model: {model_name}"	)

      for name, value in orig_dict.items():
            if should_ignore(a_    ,   a_	):
                  logger.info(f"{name} was ignored"	)
                  continue

            UpperCamelCase_				:   Any					    =							False
            for key, mapped_key in MAPPING.items():
                  if "*" in key:
                        UpperCamelCase_    ,			UpperCamelCase_				:   Optional[int]					    =							key.split(""".*."""	)
                        if prefix in name and suffix in name:
                              UpperCamelCase_				:   Tuple					    =							suffix

                  if key in name:
                        # HACK otherwise .embed gets initialized with .embed_avg too
                        if key.endswith("""embed"""	) and name.endswith("""embed_avg"""	):
                              continue

                        UpperCamelCase_				:   Optional[int]					    =							True
                        if "*" in mapped_key:
                              UpperCamelCase_				:   Any					    =							name.split(a_	)[0].split("""."""	)[-2]
                              UpperCamelCase_				:   List[Any]					    =							mapped_key.replace("""*"""    ,   a_	)
                        if "weight_g" in name:
                              UpperCamelCase_				:   List[Any]					    =							"""weight_g"""
                        elif "weight_v" in name:
                              UpperCamelCase_				:   int					    =							"""weight_v"""
                        elif "weight_ih_l0" in name:
                              UpperCamelCase_				:   List[str]					    =							"""weight_ih_l0"""
                        elif "weight_hh_l0" in name:
                              UpperCamelCase_				:   Dict					    =							"""weight_hh_l0"""
                        elif "bias_ih_l0" in name:
                              UpperCamelCase_				:   Any					    =							"""bias_ih_l0"""
                        elif "bias_hh_l0" in name:
                              UpperCamelCase_				:   str					    =							"""bias_hh_l0"""
                        elif "weight_ih_l1" in name:
                              UpperCamelCase_				:   List[str]					    =							"""weight_ih_l1"""
                        elif "weight_hh_l1" in name:
                              UpperCamelCase_				:   Optional[int]					    =							"""weight_hh_l1"""
                        elif "bias_ih_l1" in name:
                              UpperCamelCase_				:   Dict					    =							"""bias_ih_l1"""
                        elif "bias_hh_l1" in name:
                              UpperCamelCase_				:   Tuple					    =							"""bias_hh_l1"""
                        elif "bias" in name:
                              UpperCamelCase_				:   List[Any]					    =							"""bias"""
                        elif "weight" in name:
                              UpperCamelCase_				:   List[str]					    =							"""weight"""
                        elif "running_mean" in name:
                              UpperCamelCase_				:   List[str]					    =							"""running_mean"""
                        elif "running_var" in name:
                              UpperCamelCase_				:   Dict					    =							"""running_var"""
                        elif "num_batches_tracked" in name:
                              UpperCamelCase_				:   Optional[Any]					    =							"""num_batches_tracked"""
                        else:
                              UpperCamelCase_				:   Union[str, Any]					    =							None
                        set_recursively(a_    ,   a_    ,   a_    ,   a_    ,   a_	)
                  continue
            if not is_used:
                  unused_weights.append(a_	)

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



@torch.no_grad()
def 							snake_case					(     a_							: Any    ,   a_							: List[str]    ,   a_							: str    ,   a_							: int=None    ,   a_							: Union[str, Any]=None    ,   )       ->				List[Any]:





      """simple docstring"""

      if config_path is not None:
            UpperCamelCase_				:   Tuple					    =							EncodecConfig.from_pretrained(a_	)
      else:
            UpperCamelCase_				:   int					    =							EncodecConfig()

      if model_name == "encodec_24khz":
            pass  # config is already correct
      elif model_name == "encodec_32khz":
            UpperCamelCase_				:   Any					    =							[8, 5, 4, 4]
            UpperCamelCase_				:   Union[str, Any]					    =							[2.2]
            UpperCamelCase_				:   str					    =							64
            UpperCamelCase_				:   Union[str, Any]					    =							32_000
            UpperCamelCase_				:   str					    =							2_048
            UpperCamelCase_				:   Tuple					    =							False
            UpperCamelCase_				:   Dict					    =							False
            UpperCamelCase_				:   Any					    =							False
      elif model_name == "encodec_48khz":
            UpperCamelCase_				:   str					    =							[8, 5, 4, 2]
            UpperCamelCase_				:   List[str]					    =							[3.0, 6.0, 12.0, 24.0]
            UpperCamelCase_				:   Optional[Any]					    =							48_000
            UpperCamelCase_				:   str					    =							2
            UpperCamelCase_				:   str					    =							False
            UpperCamelCase_				:   List[str]					    =							"""time_group_norm"""
            UpperCamelCase_				:   Optional[Any]					    =							True
            UpperCamelCase_				:   List[Any]					    =							1.0
            UpperCamelCase_				:   List[str]					    =							0.01
      else:
            raise ValueError(f"Unknown model name: {model_name}"	)

      UpperCamelCase_				:   str					    =							EncodecModel(a_	)

      UpperCamelCase_				:   int					    =							EncodecFeatureExtractor(
          feature_size=config.audio_channels    ,   sampling_rate=config.sampling_rate    ,   chunk_length_s=config.chunk_length_s    ,   overlap=config.overlap    ,   )
      feature_extractor.save_pretrained(a_	)

      UpperCamelCase_				:   int					    =							torch.load(a_	)
      if "best_state" in original_checkpoint:
            # we might have a training state saved, in which case discard the yaml results and just retain the weights
            UpperCamelCase_				:   Any					    =							original_checkpoint["""best_state"""]
      recursively_load_weights(a_    ,   a_    ,   a_	)
      model.save_pretrained(a_	)

      if repo_id:
            print("""Pushing to the hub..."""	)
            feature_extractor.push_to_hub(a_	)
            model.push_to_hub(a_	)


if __name__ == "__main__":
      UpperCamelCase							=argparse.ArgumentParser()
      parser.add_argument(
          "--model",
          default="encodec_24khz",
          type=str,
          help="The model to convert. Should be one of 'encodec_24khz', 'encodec_32khz', 'encodec_48khz'.",
      )
      parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
      parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
      parser.add_argument(
          "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
      )
      parser.add_argument(
          "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
      )

      UpperCamelCase							=parser.parse_args()
      convert_checkpoint(
          args.model,
          args.checkpoint_path,
          args.pytorch_dump_folder_path,
          args.config_path,
          args.push_to_hub,
      )














'''simple docstring'''

import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
      from huggingface_hub import snapshot_download
      from pyctcdecode import BeamSearchDecoderCTC

      from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
      from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
      from transformers import WavaVecaForCTC




@require_pyctcdecode
class     A    (      unittest.TestCase						):






 """simple docstring"""





 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   str					    =							"""| <pad> <unk> <s> </s> a b c d e f g h i j k""".split()
       UpperCamelCase_				:   int					    =							dict(zip(__lowerCAmelCase			,     range(len(__lowerCAmelCase ) ) ) )

       UpperCamelCase_				:   Tuple					    =							{
           """unk_token""": """<unk>""",
           """bos_token""": """<s>""",
           """eos_token""": """</s>""",
       }
       UpperCamelCase_				:   Optional[Any]					    =							{
           """feature_size""": 1,
           """padding_value""": 0.0,
           """sampling_rate""": 1_60_00,
           """return_attention_mask""": False,
           """do_normalize""": True,
       }

       UpperCamelCase_				:   int					    =							tempfile.mkdtemp()
       UpperCamelCase_				:   Tuple					    =							os.path.join(self.tmpdirname			,     VOCAB_FILES_NAMES["""vocab_file"""] )
       UpperCamelCase_				:   List[Any]					    =							os.path.join(self.tmpdirname			,     __lowerCAmelCase )
       with open(self.vocab_file			,     """w"""			,     encoding="""utf-8""" ) as fp:
             fp.write(json.dumps(__lowerCAmelCase ) + """\n""" )

       with open(self.feature_extraction_file			,     """w"""			,     encoding="""utf-8""" ) as fp:
             fp.write(json.dumps(__lowerCAmelCase ) + """\n""" )

       # load decoder from hub
       UpperCamelCase_				:   Union[str, Any]					    =							"""hf-internal-testing/ngram-beam-search-decoder"""
 def   _UpperCAmelCase       (							self			,     **__lowerCAmelCase ):
       UpperCamelCase_				:   str					    =							self.add_kwargs_tokens_map.copy()
       kwargs.update(__lowerCAmelCase )
       return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     **__lowerCAmelCase ):
       return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     **__lowerCAmelCase ):
       return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name			,     **__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       shutil.rmtree(self.tmpdirname )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							self.get_tokenizer()
       UpperCamelCase_				:   str					    =							self.get_feature_extractor()
       UpperCamelCase_				:   Tuple					    =							self.get_decoder()

       UpperCamelCase_				:   int					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       processor.save_pretrained(self.tmpdirname )
       UpperCamelCase_				:   Dict					    =							WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname )

       # tokenizer
       self.assertEqual(processor.tokenizer.get_vocab()			,     tokenizer.get_vocab() )
       self.assertIsInstance(processor.tokenizer			,     __lowerCAmelCase )

       # feature extractor
       self.assertEqual(processor.feature_extractor.to_json_string()			,     feature_extractor.to_json_string() )
       self.assertIsInstance(processor.feature_extractor			,     __lowerCAmelCase )

       # decoder
       self.assertEqual(processor.decoder._alphabet.labels			,     decoder._alphabet.labels )
       self.assertEqual(
           processor.decoder.model_container[decoder._model_key]._unigram_set			,     decoder.model_container[decoder._model_key]._unigram_set			,     )
       self.assertIsInstance(processor.decoder			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							WavaVecaProcessorWithLM(
           tokenizer=self.get_tokenizer()			,     feature_extractor=self.get_feature_extractor()			,     decoder=self.get_decoder() )
       processor.save_pretrained(self.tmpdirname )

       # make sure that error is thrown when decoder alphabet doesn't match
       UpperCamelCase_				:   Optional[Any]					    =							WavaVecaProcessorWithLM.from_pretrained(
           self.tmpdirname			,     alpha=5.0			,     beta=3.0			,     score_boundary=-7.0			,     unk_score_offset=3 )

       # decoder
       self.assertEqual(processor.language_model.alpha			,     5.0 )
       self.assertEqual(processor.language_model.beta			,     3.0 )
       self.assertEqual(processor.language_model.score_boundary			,     -7.0 )
       self.assertEqual(processor.language_model.unk_score_offset			,     3 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.get_tokenizer()
       # add token to trigger raise
       tokenizer.add_tokens(["""xx"""] )
       with self.assertRaisesRegex(__lowerCAmelCase			,     """include""" ):
             WavaVecaProcessorWithLM(
                 tokenizer=__lowerCAmelCase			,     feature_extractor=self.get_feature_extractor()			,     decoder=self.get_decoder() )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Tuple					    =							self.get_feature_extractor()
       UpperCamelCase_				:   Tuple					    =							self.get_tokenizer()
       UpperCamelCase_				:   Any					    =							self.get_decoder()

       UpperCamelCase_				:   List[Any]					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   List[Any]					    =							floats_list((3, 10_00) )

       UpperCamelCase_				:   Tuple					    =							feature_extractor(__lowerCAmelCase			,     return_tensors="""np""" )
       UpperCamelCase_				:   str					    =							processor(__lowerCAmelCase			,     return_tensors="""np""" )

       for key in input_feat_extract.keys():
             self.assertAlmostEqual(input_feat_extract[key].sum()			,     input_processor[key].sum()			,     delta=1E-2 )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							self.get_feature_extractor()
       UpperCamelCase_				:   List[Any]					    =							self.get_tokenizer()
       UpperCamelCase_				:   List[Any]					    =							self.get_decoder()

       UpperCamelCase_				:   Optional[Any]					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   List[str]					    =							"""This is a test string"""

       UpperCamelCase_				:   Optional[Any]					    =							processor(text=__lowerCAmelCase )

       UpperCamelCase_				:   int					    =							tokenizer(__lowerCAmelCase )

       for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]			,     encoded_processor[key] )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase=(2, 10, 16)			,     __lowerCAmelCase=77 ):
       np.random.seed(__lowerCAmelCase )
       return np.random.rand(*__lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.get_feature_extractor()
       UpperCamelCase_				:   Tuple					    =							self.get_tokenizer()
       UpperCamelCase_				:   Optional[int]					    =							self.get_decoder()

       UpperCamelCase_				:   int					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   List[str]					    =							self._get_dummy_logits(shape=(10, 16)			,     seed=13 )

       UpperCamelCase_				:   Any					    =							processor.decode(__lowerCAmelCase )

       UpperCamelCase_				:   Any					    =							decoder.decode_beams(__lowerCAmelCase )[0]

       self.assertEqual(decoded_decoder[0]			,     decoded_processor.text )
       self.assertEqual("""</s> <s> </s>"""			,     decoded_processor.text )
       self.assertEqual(decoded_decoder[-2]			,     decoded_processor.logit_score )
       self.assertEqual(decoded_decoder[-1]			,     decoded_processor.lm_score )
 @parameterized.expand([[None], ["""fork"""], ["""spawn"""]] )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Union[str, Any]					    =							self.get_feature_extractor()
       UpperCamelCase_				:   str					    =							self.get_tokenizer()
       UpperCamelCase_				:   List[Any]					    =							self.get_decoder()

       UpperCamelCase_				:   Optional[Any]					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   Union[str, Any]					    =							self._get_dummy_logits()

       # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
       #       otherwise, the LM won't be available to the pool's sub-processes.
       # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
       if pool_context is None:
             UpperCamelCase_				:   List[Any]					    =							processor.batch_decode(__lowerCAmelCase )
       else:
             with get_context(__lowerCAmelCase ).Pool() as pool:
                   UpperCamelCase_				:   Any					    =							processor.batch_decode(__lowerCAmelCase			,     __lowerCAmelCase )

       UpperCamelCase_				:   Tuple					    =							list(__lowerCAmelCase )

       with get_context("""fork""" ).Pool() as p:
             UpperCamelCase_				:   Optional[int]					    =							decoder.decode_beams_batch(__lowerCAmelCase			,     __lowerCAmelCase )

       UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_				:   Union[str, Any]					    =							[], [], []
       for beams in decoded_beams:
             texts_decoder.append(beams[0][0] )
             logit_scores_decoder.append(beams[0][-2] )
             lm_scores_decoder.append(beams[0][-1] )

       self.assertListEqual(__lowerCAmelCase			,     decoded_processor.text )
       self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""]			,     decoded_processor.text )
       self.assertListEqual(__lowerCAmelCase			,     decoded_processor.logit_score )
       self.assertListEqual(__lowerCAmelCase			,     decoded_processor.lm_score )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							self.get_feature_extractor()
       UpperCamelCase_				:   Tuple					    =							self.get_tokenizer()
       UpperCamelCase_				:   Tuple					    =							self.get_decoder()

       UpperCamelCase_				:   Optional[Any]					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   List[str]					    =							self._get_dummy_logits()

       UpperCamelCase_				:   Dict					    =							15
       UpperCamelCase_				:   str					    =							-20.0
       UpperCamelCase_				:   Dict					    =							-4.0

       UpperCamelCase_				:   Union[str, Any]					    =							processor.batch_decode(
           __lowerCAmelCase			,     beam_width=__lowerCAmelCase			,     beam_prune_logp=__lowerCAmelCase			,     token_min_logp=__lowerCAmelCase			,     )
       UpperCamelCase_				:   Any					    =							decoded_processor_out.text

       UpperCamelCase_				:   Tuple					    =							list(__lowerCAmelCase )

       with get_context("""fork""" ).Pool() as pool:
             UpperCamelCase_				:   str					    =							decoder.decode_beams_batch(
                 __lowerCAmelCase			,     __lowerCAmelCase			,     beam_width=__lowerCAmelCase			,     beam_prune_logp=__lowerCAmelCase			,     token_min_logp=__lowerCAmelCase			,     )

       UpperCamelCase_				:   str					    =							[d[0][0] for d in decoded_decoder_out]
       UpperCamelCase_				:   List[str]					    =							[d[0][2] for d in decoded_decoder_out]
       UpperCamelCase_				:   Union[str, Any]					    =							[d[0][3] for d in decoded_decoder_out]

       self.assertListEqual(__lowerCAmelCase			,     __lowerCAmelCase )
       self.assertListEqual(["""</s> <s> <s>""", """<s> <s> <s>"""]			,     __lowerCAmelCase )

       self.assertTrue(np.array_equal(__lowerCAmelCase			,     decoded_processor_out.logit_score ) )
       self.assertTrue(np.allclose([-20.0_54, -18.4_47]			,     __lowerCAmelCase			,     atol=1E-3 ) )

       self.assertTrue(np.array_equal(__lowerCAmelCase			,     decoded_processor_out.lm_score ) )
       self.assertTrue(np.allclose([-15.5_54, -13.94_74]			,     __lowerCAmelCase			,     atol=1E-3 ) )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							self.get_feature_extractor()
       UpperCamelCase_				:   Union[str, Any]					    =							self.get_tokenizer()
       UpperCamelCase_				:   int					    =							self.get_decoder()

       UpperCamelCase_				:   Dict					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       UpperCamelCase_				:   str					    =							self._get_dummy_logits()

       UpperCamelCase_				:   Optional[int]					    =							2.0
       UpperCamelCase_				:   List[str]					    =							5.0
       UpperCamelCase_				:   Optional[Any]					    =							-20.0
       UpperCamelCase_				:   Optional[Any]					    =							True

       UpperCamelCase_				:   Union[str, Any]					    =							processor.batch_decode(
           __lowerCAmelCase			,     alpha=__lowerCAmelCase			,     beta=__lowerCAmelCase			,     unk_score_offset=__lowerCAmelCase			,     lm_score_boundary=__lowerCAmelCase			,     )
       UpperCamelCase_				:   List[str]					    =							decoded_processor_out.text

       UpperCamelCase_				:   List[str]					    =							list(__lowerCAmelCase )
       decoder.reset_params(
           alpha=__lowerCAmelCase			,     beta=__lowerCAmelCase			,     unk_score_offset=__lowerCAmelCase			,     lm_score_boundary=__lowerCAmelCase			,     )

       with get_context("""fork""" ).Pool() as pool:
             UpperCamelCase_				:   int					    =							decoder.decode_beams_batch(
                 __lowerCAmelCase			,     __lowerCAmelCase			,     )

       UpperCamelCase_				:   Any					    =							[d[0][0] for d in decoded_decoder_out]

       self.assertListEqual(__lowerCAmelCase			,     __lowerCAmelCase )
       self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""]			,     __lowerCAmelCase )
       UpperCamelCase_				:   Union[str, Any]					    =							processor.decoder.model_container[processor.decoder._model_key]
       self.assertEqual(lm_model.alpha			,     2.0 )
       self.assertEqual(lm_model.beta			,     5.0 )
       self.assertEqual(lm_model.unk_score_offset			,     -20.0 )
       self.assertEqual(lm_model.score_boundary			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" )

       UpperCamelCase_				:   Optional[int]					    =							processor.decoder.model_container[processor.decoder._model_key]
       UpperCamelCase_				:   int					    =							Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute()

       UpperCamelCase_				:   Any					    =							os.listdir(__lowerCAmelCase )
       UpperCamelCase_				:   Optional[Any]					    =							["""alphabet.json""", """language_model"""]

       downloaded_decoder_files.sort()
       expected_decoder_files.sort()

       # test that only decoder relevant files from
       # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
       # are downloaded and none of the rest (e.g. README.md, ...)
       self.assertListEqual(__lowerCAmelCase			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							snapshot_download("""hf-internal-testing/processor_with_lm""" )

       UpperCamelCase_				:   Union[str, Any]					    =							WavaVecaProcessorWithLM.from_pretrained(__lowerCAmelCase )

       UpperCamelCase_				:   Union[str, Any]					    =							processor.decoder.model_container[processor.decoder._model_key]
       UpperCamelCase_				:   Tuple					    =							Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute()

       UpperCamelCase_				:   Union[str, Any]					    =							os.listdir(__lowerCAmelCase )
       UpperCamelCase_				:   str					    =							os.listdir(__lowerCAmelCase )

       local_decoder_files.sort()
       expected_decoder_files.sort()

       # test that both decoder form hub and local files in cache are the same
       self.assertListEqual(__lowerCAmelCase			,     __lowerCAmelCase )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Any					    =							WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" )
       UpperCamelCase_				:   Tuple					    =							AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" )

       UpperCamelCase_				:   Dict					    =							floats_list((3, 10_00) )

       UpperCamelCase_				:   List[Any]					    =							processor_wavaveca(__lowerCAmelCase			,     return_tensors="""np""" )
       UpperCamelCase_				:   Tuple					    =							processor_auto(__lowerCAmelCase			,     return_tensors="""np""" )

       for key in input_wavaveca.keys():
             self.assertAlmostEqual(input_wavaveca[key].sum()			,     input_auto[key].sum()			,     delta=1E-2 )

       UpperCamelCase_				:   Optional[int]					    =							self._get_dummy_logits()

       UpperCamelCase_				:   Dict					    =							processor_wavaveca.batch_decode(__lowerCAmelCase )
       UpperCamelCase_				:   Any					    =							processor_auto.batch_decode(__lowerCAmelCase )

       self.assertListEqual(decoded_wavaveca.text			,     decoded_auto.text )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Tuple					    =							self.get_feature_extractor()
       UpperCamelCase_				:   int					    =							self.get_tokenizer()
       UpperCamelCase_				:   List[Any]					    =							self.get_decoder()

       UpperCamelCase_				:   List[str]					    =							WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase			,     feature_extractor=__lowerCAmelCase			,     decoder=__lowerCAmelCase )

       self.assertListEqual(
           processor.model_input_names			,     feature_extractor.model_input_names			,     msg="""`processor` and `feature_extractor` model input names do not match"""			,     )
 @staticmethod
 def   _UpperCAmelCase       (							__lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Union[str, Any]					    =							[d[key] for d in offsets]
       return retrieved_list
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Dict					    =							WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" )
       UpperCamelCase_				:   int					    =							self._get_dummy_logits()[0]

       UpperCamelCase_				:   List[Any]					    =							processor.decode(__lowerCAmelCase			,     output_word_offsets=__lowerCAmelCase )
       # check Wav2Vec2CTCTokenizerOutput keys for word
       self.assertEqual(len(outputs.keys() )			,     4 )
       self.assertTrue("""text""" in outputs )
       self.assertTrue("""word_offsets""" in outputs )
       self.assertTrue(isinstance(__lowerCAmelCase			,     __lowerCAmelCase ) )

       self.assertEqual(""" """.join(self.get_from_offsets(outputs["""word_offsets"""]			,     """word""" ) )			,     outputs.text )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]			,     """word""" )			,     ["""<s>""", """<s>""", """</s>"""] )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]			,     """start_offset""" )			,     [0, 2, 4] )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]			,     """end_offset""" )			,     [1, 3, 5] )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Any					    =							WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" )
       UpperCamelCase_				:   Union[str, Any]					    =							self._get_dummy_logits()

       UpperCamelCase_				:   Dict					    =							processor.batch_decode(__lowerCAmelCase			,     output_word_offsets=__lowerCAmelCase )

       # check Wav2Vec2CTCTokenizerOutput keys for word
       self.assertEqual(len(outputs.keys() )			,     4 )
       self.assertTrue("""text""" in outputs )
       self.assertTrue("""word_offsets""" in outputs )
       self.assertTrue(isinstance(__lowerCAmelCase			,     __lowerCAmelCase ) )

       self.assertListEqual(
           [""" """.join(self.get_from_offsets(__lowerCAmelCase			,     """word""" ) ) for o in outputs["""word_offsets"""]]			,     outputs.text )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]			,     """word""" )			,     ["""<s>""", """<s>""", """</s>"""] )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]			,     """start_offset""" )			,     [0, 2, 4] )
       self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]			,     """end_offset""" )			,     [1, 3, 5] )





 @slow
 @require_torch
 @require_torchaudio
 def   _UpperCAmelCase       (							self ):
       import torch

       UpperCamelCase_				:   str					    =							load_dataset("""common_voice"""			,     """en"""			,     split="""train"""			,     streaming=__lowerCAmelCase )
       UpperCamelCase_				:   Union[str, Any]					    =							ds.cast_column("""audio"""			,     datasets.Audio(sampling_rate=1_60_00 ) )
       UpperCamelCase_				:   Union[str, Any]					    =							iter(__lowerCAmelCase )
       UpperCamelCase_				:   int					    =							next(__lowerCAmelCase )

       UpperCamelCase_				:   List[str]					    =							AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" )
       UpperCamelCase_				:   Tuple					    =							WavaVecaForCTC.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" )

       # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
       UpperCamelCase_				:   Dict					    =							processor(sample["""audio"""]["""array"""]			,     return_tensors="""pt""" ).input_values

       with torch.no_grad():
             UpperCamelCase_				:   List[Any]					    =							model(__lowerCAmelCase ).logits.cpu().numpy()

       UpperCamelCase_				:   Tuple					    =							processor.decode(logits[0]			,     output_word_offsets=__lowerCAmelCase )

       UpperCamelCase_				:   List[Any]					    =							model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
       UpperCamelCase_				:   Dict					    =							[
           {
               """start_time""": d["""start_offset"""] * time_offset,
               """end_time""": d["""end_offset"""] * time_offset,
               """word""": d["""word"""],
           }
           for d in output["""word_offsets"""]
       ]

       UpperCamelCase_				:   Optional[Any]					    =							"""WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"""

       # output words
       self.assertEqual(""" """.join(self.get_from_offsets(__lowerCAmelCase			,     """word""" ) )			,     __lowerCAmelCase )
       self.assertEqual(""" """.join(self.get_from_offsets(__lowerCAmelCase			,     """word""" ) )			,     output.text )

       # output times
       UpperCamelCase_				:   str					    =							torch.tensor(self.get_from_offsets(__lowerCAmelCase			,     """start_time""" ) )
       UpperCamelCase_				:   Union[str, Any]					    =							torch.tensor(self.get_from_offsets(__lowerCAmelCase			,     """end_time""" ) )

       # fmt: off
       UpperCamelCase_				:   Union[str, Any]					    =							torch.tensor([1.41_99, 1.65_99, 2.25_99, 3.0, 3.24, 3.59_99, 3.79_99, 4.09_99, 4.26, 4.94, 5.28, 5.65_99, 5.78, 5.94, 6.32, 6.53_99, 6.65_99] )
       UpperCamelCase_				:   Union[str, Any]					    =							torch.tensor([1.53_99, 1.89_99, 2.9, 3.16, 3.53_99, 3.72, 4.01_99, 4.17_99, 4.76, 5.15_99, 5.55_99, 5.69_99, 5.86, 6.19_99, 6.38, 6.61_99, 6.94] )
       # fmt: on

       self.assertTrue(torch.allclose(__lowerCAmelCase			,     __lowerCAmelCase			,     atol=0.01 ) )
       self.assertTrue(torch.allclose(__lowerCAmelCase			,     __lowerCAmelCase			,     atol=0.01 ) )






