code: def find_audio_files(
      path: tp.Union[Path, str],
      exts: tp.List[str] = DEFAULT_EXTS,
      resolve: bool = True,
      minimal: bool = True,
      progress: bool = False,
      workers: int = 0,
  ) -> tp.List[AudioMeta]:
      """Build a list of AudioMeta from a given path,
      collecting relevant audio files and fetching meta info.
  
      Args:
          path (str or Path): Path to folder containing audio files.
          exts (list of str): List of file extensions to consider for audio files.
          minimal (bool): Whether to only load the minimal set of metadata (takes longer if not).
          progress (bool): Whether to log progress on audio files collection.
          workers (int): number of parallel workers, if 0, use only the current thread.
      Returns:
          list of AudioMeta: List of audio file path and its metadata.
      """
      audio_files = []
      futures: tp.List[Future] = []
      pool: tp.Optional[ThreadPoolExecutor] = None
      with ExitStack() as stack:
          if workers > 0:
              pool = ThreadPoolExecutor(workers)
              stack.enter_context(pool)
  
          if progress:
              print("Finding audio files...")
          for root, folders, files in os.walk(path, followlinks=True):
              for file in files:
                  full_path = Path(root) / file
                  if full_path.suffix.lower() in exts:
                      audio_files.append(full_path)
                      if pool is not None:
                          futures.append(
                              pool.submit(
                                  _get_audio_meta,
                                  str(audio_files[-1]),
                                  minimal,
                              )
                          )
                      if progress:
                          print(
                              format(len(audio_files), " 8d"),
                              end="\r",
                              file=sys.stderr,
                          )
  
          if progress:
              print("Getting audio metadata...")
          meta: tp.List[AudioMeta] = []
          for idx, file_path in enumerate(audio_files):
              try:
                  if pool is None:
                      m = _get_audio_meta(str(file_path), minimal)
                  else:
                      m = futures[idx].result()
                  if resolve:
                      m = _resolve_audio_meta(m)
              except Exception as err:
                  print(
                      "Error with", str(file_path), err, file=sys.stderr
                  )
                  continue
              meta.append(m)
              if progress:
                  print(
                      format((1 + idx) / len(audio_files), " 3.1%"),
                      end="\r",
                      file=sys.stderr,
                  )
      meta.sort()
      return meta
  
imports: import argparse
  import copy
  from concurrent.futures import ThreadPoolExecutor, Future
  from dataclasses import dataclass, fields
  from contextlib import ExitStack
  from functools import lru_cache
  import gzip
  import json
  import logging
  import os
  from pathlib import Path
  import random
  import sys
  import typing
  import torch
  import torch.nn.functional
  from .audio import audio_read, audio_info
  from .audio_utils import convert_audio
  from .zip import PathInZip
label_desc: Use image node_id 3 for calling a global function with example usage: find_audio_files(path, exts, resolve, minimal, progress, workers) and returns: meta