class_docstr: Class for processing and loading Vocoder training examples.
  
  Args:
      dataset_meta: Dict of dataset names (string) to dataset metadata.
      sample_rate: Sample rate to load audio as. If the audio is stored at a different sample rate, then it will
          be resampled.
      n_samples: Optional int, if provided then n_samples samples will be randomly sampled from the full
          audio file.
      weighted_sampling_steps_per_epoch: Optional int, If provided, then data will be sampled (with replacement) based on
          the sample weights provided in the dataset metadata. If None, then sample weights will be ignored.
      feature_processors: Optional, list of feature processors to run on training examples.
      min_duration: Optional float, if provided audio files in the training manifest shorter than 'min_duration'
          will be ignored.
      max_duration: Optional float, if provided audio files in the training manifest longer than 'max_duration'
          will be ignored.
      trunc_duration: Optional int, if provided audio will be truncated to at most 'trunc_duration' seconds.
      volume_norm: Whether to apply volume normalization to loaded audio.
code: def __init__(
      self,
      dataset_meta: Dict,
      sample_rate: int,
      n_samples: Optional[int] = None,
      weighted_sampling_steps_per_epoch: Optional[int] = None,
      feature_processors: Optional[Dict[str, FeatureProcessor]] = None,
      min_duration: Optional[float] = None,
      max_duration: Optional[float] = None,
      trunc_duration: Optional[float] = None,
      volume_norm: bool = False,
  ):
      super().__init__()
  
      self.sample_rate = sample_rate
      self.n_samples = n_samples
      self.trunc_duration = trunc_duration
      self.volume_norm = volume_norm
      self.weighted_sampling_steps_per_epoch = (
          weighted_sampling_steps_per_epoch
      )
      self.load_precomputed_mel = False
  
      if feature_processors:
          logging.info(
              f"Found feature processors {feature_processors.keys()}"
          )
          self.feature_processors = list(feature_processors.values())
      else:
          self.feature_processors = []
  
      self.data_samples = []
      self.sample_weights = []
      for dataset_name, dataset_info in dataset_meta.items():
          dataset = DatasetMeta(**dataset_info)
          samples, weights = preprocess_manifest(
              dataset_name=dataset_name,
              dataset=dataset,
              min_duration=min_duration,
              max_duration=max_duration,
          )
          self.data_samples += samples
          self.sample_weights += weights
  
imports: import io
  import os
  from dataclasses import dataclass
  from pathlib import Path
  from typing import Dict, List, Optional
  import librosa
  import soundfile
  import torch.utils.data
  import webdataset
  from nemo.collections.asr.data.audio_to_text import expand_sharded_filepaths
  from nemo.collections.asr.parts.preprocessing.segment import available_formats
  from nemo.collections.asr.parts.utils.manifest_utils import read_manifest
  from nemo.collections.tts.parts.preprocessing.feature_processors import FeatureProcessor
  from nemo.collections.tts.parts.utils.tts_dataset_utils import filter_dataset_by_duration, get_weighted_sampler, load_audio, sample_audio, stack_tensors
  from nemo.core.classes import Dataset, IterableDataset
  from nemo.utils import logging
  from nemo.utils.decorators import experimental
label_desc: Use image node_id 1 to create a new VocoderDataset object from inherited base classes: Dataset with example: obj = VocoderDataset(dataset_meta, sample_rate, n_samples, weighted_sampling_steps_per_epoch, feature_processors, min_duration, max_duration, trunc_duration, volume_norm)