code: def __init__(
      self,
      manifest_path: str,
      sample_rate: float,
      label_paths: List[str],
      label_rates: Union[List[float], float],  # -1 for sequence labels
      pad_list: List[str],
      eos_list: List[str],
      label_processors: Optional[List[Any]] = None,
      max_keep_sample_size: Optional[int] = None,
      min_keep_sample_size: Optional[int] = None,
      max_sample_size: Optional[int] = None,
      shuffle: bool = True,
      pad_audio: bool = False,
      normalize: bool = False,
      store_labels: bool = True,
      random_crop: bool = False,
      single_target: bool = False,
  ):
      (
          self.audio_root,
          self.audio_names,
          inds,
          tot,
          self.sizes,
      ) = load_audio(
          manifest_path, max_keep_sample_size, min_keep_sample_size
      )
      self.sample_rate = sample_rate
      self.shuffle = shuffle
      self.random_crop = random_crop
  
      self.num_labels = len(label_paths)
      self.pad_list = pad_list
      self.eos_list = eos_list
      self.label_processors = label_processors
      self.single_target = single_target
      self.label_rates = (
          [label_rates for _ in range(len(label_paths))]
          if isinstance(label_rates, float)
          else label_rates
      )
      self.store_labels = store_labels
      if store_labels:
          self.label_list = [
              load_label(p, inds, tot) for p in label_paths
          ]
      else:
          self.label_paths = label_paths
          self.label_offsets_list = [
              load_label_offset(p, inds, tot) for p in label_paths
          ]
      assert (
          label_processors is None
          or len(label_processors) == self.num_labels
      )
      for label_path, label_rate in zip(label_paths, self.label_rates):
          verify_label_lengths(
              self.sizes, sample_rate, label_path, label_rate, inds, tot
          )
  
      self.max_sample_size = (
          max_sample_size
          if max_sample_size is not None
          else sys.maxsize
      )
      self.pad_audio = pad_audio
      self.normalize = normalize
      logger.info(
          f"pad_audio={pad_audio}, random_crop={random_crop}, "
          f"normalize={normalize}, max_sample_size={self.max_sample_size}"
      )
  
imports: import itertools
  import logging
  import os
  import sys
  from typing import Any, List, Optional, Union
  import numpy
  import torch
  import torch.nn.functional
  from fairseq.data import data_utils
  from fairseq.data.fairseq_dataset import FairseqDataset
  from fairseq.data.audio.audio_utils import parse_path, read_from_stored_zip
  import io
label_desc: Use image node_id 1 to create a new HubertDataset object from inherited base classes: FairseqDataset with example: obj = HubertDataset(manifest_path, sample_rate, label_paths, label_rates, pad_list, eos_list, label_processors, max_keep_sample_size, min_keep_sample_size, max_sample_size, shuffle, pad_audio, normalize, store_labels, random_crop, single_target)