code: def collect_data_st(
      data_dir: Union[Path, str],
      split: str,
      prefix: str,
      src: str,
      tgt: str,
  ) -> List[List[Utterance]]:
      in_root = data_dir / "raw_audios" / tgt
      asr_root = data_dir / "transcribed_data" / src
      st_root = data_dir / "transcribed_data" / tgt
      asr_root.mkdir(exist_ok=True, parents=True)
      st_root.mkdir(exist_ok=True, parents=True)
  
      # Get metadata TSV
      url = f"{DOWNLOAD_BASE_URL}/annotations/asr/asr_{src}.tsv.gz"
      tsv_path = asr_root / Path(url).name
      if not tsv_path.exists():
          try:
              download_url(url, asr_root.as_posix(), Path(url).name)
          except urllib.error.HTTPError:
              logging.warning(f"cannot download {url}. Skip")
              return []
  
      with gzip.open(tsv_path, "rt") as f:
          src_metadata = [x for x in csv.DictReader(f, delimiter="|")]
          src_metadata = {
              "{}-{}".format(r["session_id"], r["id_"]): (
                  r["original_text"]
                  if len(r["original_text"].strip()) > 0
                  else r["normed_text"],
                  r["split"],
              )
              for r in src_metadata
          }
  
      url = f"{DOWNLOAD_BASE_URL}/annotations/s2s/s2s_{tgt}_ref.tsv.gz"
      # Note(jinchuan): st label is irrelevent to "src" lang.
      # Don't download it for multiple times
      tsv_path = st_root / Path(url).name
      if not tsv_path.exists():
          try:
              download_url(url, st_root.as_posix(), Path(url).name)
          except urllib.error.HTTPError:
              logging(f"cannot download {url}. Skip")
              return []
      with gzip.open(tsv_path, "rt") as f:
          tgt_metadata = [x for x in csv.DictReader(f, delimiter="\t")]
  
      talks = {}
      for r in tgt_metadata:
          src_id = r["id"]
          event_id, _src, utt_id = parse_src_id(src_id)
          # Note(jinchuan): not sure if the segments are contiguous.
          if _src != src:
              continue
  
          # Note(Jinchuan): ST data do not have explicit split. Inherit it from ASR data
          src_text, _split = src_metadata.get(src_id, (None, None))
          if src_text is None:
              logging.warning(
                  f"src: {src} | tgt: {tgt} | missing key in src: {src_id}"
              )
              continue
  
          if _split != split:
              continue
  
          src_text = preprocess_text(src_text)
          if len(src_text.strip()) == 0:
              logging.warning(
                  f"example {src_id} has empty src text. Skip. {r}"
              )
              continue
  
          year = event_id[:4]
          audio_path = in_root / year / f"{event_id}_{tgt}.ogg"
          assert audio_path.is_file()
  
          tgt_text = r["tgt_text"]
          tgt_text = preprocess_text(tgt_text)
          if len(tgt_text.strip()) == 0:
              logging.warning(
                  f"example {src_id} has empty tgt text. Skip. {r}"
              )
              continue
  
          if event_id not in talks:
              talks[event_id] = []
  
          if float(r["end_time"]) - float(r["start_time"]) < 0.1:
              logging.warning(f"the utterance is too short. Skip: {r}")
  
          # Note(jinchuan): Not sure if "event_id" would overlap across
          # languages. So add src2tgt tag to wav_id to exclude this risk
          iso_src, iso_tgt = toiso(src), toiso(tgt)
          path_template = "ffmpeg -i {} -ac 1 -ar 16000 -f wav - |"
          talks[event_id].append(
              Utterance(
                  utt_id=f"{prefix}_st_{iso_src}2{iso_tgt}_{event_id}_{utt_id}",
                  wav_id=f"{prefix}_st_{iso_src}2{iso_tgt}_{event_id}",
                  wav_path=path_template.format(
                      str(audio_path.resolve())
                  ),
                  start_time=float(r["start_time"]),
                  end_time=float(r["end_time"]),
                  lang=f"<{iso_src}>",
                  task=f"<st_{iso_tgt}>",
                  text=tgt_text,
                  asr_text=src_text,
              )
          )
  
      return list(talks.values())
  
file_path: espnet/egs2/owsm_v3/s2t1/local/prepare_voxpopuli.py
imports: import csv
  import gzip
  import json
  import logging
  import urllib
  from argparse import ArgumentParser
  from ast import literal_eval
  from collections import defaultdict
  from pathlib import Path
  from typing import Dict, List, Optional, Tuple, Union
  from iso639 import languages
  from torchaudio.datasets.utils import download_url
  from utils import SYMBOL_NA, SYMBOL_NOSPEECH, SYMBOLS_TIME, LongUtterance, Utterance, generate_long_utterances
label_desc: Use image node_id 5 for calling a global function with example usage: collect_data_st(data_dir, split, prefix, src, tgt) and returns: list, list, list