code: def _show_prog(
      queues: Tuple[mp.Queue, ...],
      totals: List[int],
      descriptions: List[str],
      units: List[str],
  ) -> None:
      """
      Show several ``tqdm`` progress bars.
      Args:
          queues: a list of queues by which progress is delivered into this function. Each queue is responsible for one
              progress bar. ``show_prog`` function extracts integers from ``queues`` elements and adds them to progress
              bars. If value extracted from a queue equals ``-1``, then corresponding progress bar is closed. When all
              progress bars are closed, this function returns.
          totals: list of values 100% of progress bars. See more in a description of ``total`` parameter of
              ``tqdm.tqdm`` function
          descriptions: list of descriptions of progress bars. See more in a description of ``desc`` parameter of
              ``tqdm.tqdm`` function
          units: list of progress bar units. See more in a description of ``unit`` parameter of ``tqdm.tqdm`` function
      """
      if not all(
          [len(queues) == len(v) for v in [totals, descriptions, units]]
      ):
          raise ValueError(
              f"All of parameters `queues`, `total_num_lines`, `descriptions`, `units` have to have equal lengths. "
              f"len(queues)={len(queues)}, len(total_num_lines)={len(totals)}, "
              f"len(descriptions)={len(descriptions)}, len(units)={len(units)}."
          )
      prog = [
          tqdm(total=tt, desc=dd, unit=uu, unit_scale=True, position=i)
          for i, (tt, dd, uu) in enumerate(
              zip(totals, descriptions, units)
          )
      ]
      finished = [False] * len(queues)
      while True:
          for i, queue in enumerate(queues):
              stop = False
              to_add = 0
              try:
                  v = queue.get(block=False)
                  while v != -1:
                      to_add += v
                      v = queue.get(block=False)
                  stop = True
              except Empty:
                  if to_add == 0 and not stop:
                      continue
              prog[i].n += to_add
              prog[i].update(0)
              if prog[i].n >= totals[i]:
                  finished[i] = True
                  prog[i].close()
              if stop:
                  if prog[i].n < totals[i]:
                      logging.warning(
                          f"Progress with description '{descriptions[i]}' terminated before progress bar "
                          f"reached 100%. prog.n={prog[i].n}, total_num_lines={totals[i]}"
                      )
                  finished[i] = True
                  prog[i].close()
          if all(finished):
              break
          sleep(0.1)
  
imports: import itertools
  import multiprocessing
  import os
  import pickle
  import tempfile
  from dataclasses import dataclass
  from math import ceil
  from pathlib import Path
  from queue import Empty
  from time import sleep
  from typing import Any, Dict, List, Optional, Set, Tuple, Union
  import numpy
  import torch
  from numpy import ndarray
  from omegaconf import MISSING, DictConfig, OmegaConf
  from torch.nn.utils.rnn import pad_sequence
  from tqdm import tqdm
  from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec
  from nemo.collections.nlp.data.data_utils.data_preprocessing import get_label_stats, get_stats
  from nemo.core.classes import Dataset
  from nemo.core.neural_types import AudioSignal, ChannelType, LabelsType, LengthsType, MaskType, NeuralType
  from nemo.utils import logging
  from nemo.utils.get_rank import is_global_rank_zero
label_desc: Use image node_id 4 for calling a global function with example usage: _show_prog(queues, totals, descriptions, units) without return types