class_docstr: Dataset that loads tensors via a json file containing paths to audio feature files, transcripts,
  durations (in seconds) and optional RTTM files. Each new line is a different sample. Example below:
  {"feature_filepath": "/path/to/audio_feature.pt", "text_filepath": "/path/to/audio.txt", 
  "rttm_filepath": "/path/to/audio_rttm.rttm", "duration": 23.147}
  ...
  {"feature_filepath": "/path/to/audio_feature.pt", "text": "the transcription", "offset": 301.75, "duration": 0.82, "utt":
  "utterance_id", "ctm_utt": "en_4156", "side": "A"}
  Args:
      manifest_filepath (str): Path to manifest json as described above. Can be comma-separated paths.
      parser: Str for a language specific preprocessor or a callable.
      normalize (bool): whether and where to normalize feature, must be one of [None, "post_norm", "pre_norm"]
      normalize_type (Union[str, dict]): how to normalize feature, see `nemo.collections.asr.parts.preprocessing.features.normalize_batch`
      use_rttm (bool): whether to use RTTM files if there is any, default to False
      rttm_mode (str): how to use RTTM files, must be one of ['mask', 'drop'], default to 'mask'
      feat_min_len (int): minimum length of feature when rttm_mode=deop, default to 4.
      feat_mask_val (Optional[float]): value used to mask features with RTTM files, default to None to use zero mel-spectralgram
      frame_unit_time_secs (float): time in seconds for each frame
      sample_rate (int): Sample rate to resample loaded audio to
      int_values (bool): If true, load samples as 32-bit integers. Defauts to False.
      augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor): An AudioAugmentor object used to augment loaded audio
      max_duration (float): If audio exceeds this length, do not include in dataset
      min_duration (float): If audio is less than this length, do not include in dataset
      max_utts (int): Limit number of utterances
      trim (bool): whether or not to trim silence. Defaults to False
      bos_id (int): Id of beginning of sequence symbol to append if not None
      eos_id (int): Id of end of sequence symbol to append if not None
      pad_id (int): Id of pad symbol. Defaults to 0
      return_sample_id (bool): whether to return the sample_id as a part of each sample
      channel_selector (int | Iterable[int] | str): select a single channel or a subset of channels from multi-channel audio. If set to `'average'`, it performs averaging across channels. Disabled if set to `None`. Defaults to `None`. Uses zero-based indexing.
code: def __init__(
      self,
      manifest_filepath: str,
      parser: Union[str, Callable],
      normalize: Optional[str] = "post_norm",
      normalize_type: Union[str, dict] = "per_feature",
      use_rttm: bool = False,
      rttm_mode: str = "mask",
      feat_min_len: int = 4,
      feat_mask_val: Optional[float] = None,
      frame_unit_time_secs: float = 0.01,
      sample_rate: Optional[int] = 16000,
      augmentor: "nemo.collections.asr.parts.perturb.FeatureAugmentor" = None,
      max_duration: Optional[int] = None,
      min_duration: Optional[int] = None,
      max_utts: int = 0,
      trim: bool = False,
      bos_id: Optional[int] = None,
      eos_id: Optional[int] = None,
      pad_id: int = 0,
      return_sample_id: bool = False,
      channel_selector: Optional[ChannelSelectorType] = None,
  ):
      if type(manifest_filepath) == str:
          manifest_filepath = manifest_filepath.split(",")
  
      self.sample_rate = sample_rate
      self.normalize = normalize
      self.normalize_type = normalize_type
      self.use_rttm = use_rttm
      self.rttm_mode = rttm_mode
      if self.use_rttm and self.rttm_mode not in self.RTTM_MODES:
          raise ValueError(
              f"`rttm_mode` must be one of {self.RTTM_MODES}, got `{rttm_mode}` instead"
          )
  
      self.feat_min_len = feat_min_len
      if feat_mask_val is not None:
          self.feat_mask_val = feat_mask_val
      elif normalize == "pre_norm":
          self.feat_mask_val = 0.0  # similar to SpectralAugmentation
      else:
          self.feat_mask_val = self.ZERO_LEVEL_SPEC_DB_VAL
  
      if normalize is not None and normalize not in self.NORM_MODES:
          raise ValueError(
              f"`normalize` must be one of {self.NORM_MODES}, got `{normalize}` instead"
          )
  
      self.frame_unit_time_secs = frame_unit_time_secs
  
      self.manifest_processor = ASRFeatureManifestProcessor(
          manifest_filepath=manifest_filepath,
          parser=parser,
          max_duration=max_duration,
          min_duration=min_duration,
          max_utts=max_utts,
          bos_id=bos_id,
          eos_id=eos_id,
          pad_id=pad_id,
      )
      self.featurizer = ExternalFeatureLoader(augmentor=augmentor)
      self.trim = trim
      self.return_sample_id = return_sample_id
      self.channel_selector = channel_selector
  
imports: from typing import Callable, Dict, List, Optional, Tuple, Union
  import torch
  from nemo.collections.asr.data.feature_to_label import _audio_feature_collate_fn
  from nemo.collections.asr.parts.preprocessing.feature_loader import ExternalFeatureLoader
  from nemo.collections.asr.parts.preprocessing.features import normalize_batch
  from nemo.collections.asr.parts.utils.audio_utils import ChannelSelectorType
  from nemo.collections.asr.parts.utils.vad_utils import load_speech_segments_from_rttm
  from nemo.collections.common import tokenizers
  from nemo.collections.common.parts.preprocessing import collections, parsers
  from nemo.core.classes import Dataset
  from nemo.core.neural_types import AcousticEncodedRepresentation, LabelsType, LengthsType, NeuralType
label_desc: Use image node_id 2 to create a new _FeatureTextDataset object from inherited base classes: Dataset with example: obj = _FeatureTextDataset(manifest_filepath, parser, normalize, normalize_type, use_rttm, rttm_mode, feat_min_len, feat_mask_val, frame_unit_time_secs, sample_rate, augmentor, max_duration, min_duration, max_utts, trim, bos_id, eos_id, pad_id, return_sample_id, channel_selector)