code: def prep_audio(
      waveforms: List[np.ndarray], batch_size: int, truncate=False
  ) -> np.ndarray:
      """
      :param waveforms: A list of possibly variable length 16000Hz audio samples
      :param batch_size: The batch_size associated with the Whisper model being used to transcribe the audio.
                         Used to prevent JIT mismatch errors since the encoder does not accept symbolic shapes
      :param truncate: If true, truncates (or pads) audio to exactly 30s for a single encoder pass
      :return: mel spectrogram of the given waveforms
      """
  
      def pad_or_trim(arr, target_len):
          curr_len = len(arr)
          if curr_len == target_len:
              return arr
          elif curr_len < target_len:
              return np.pad(arr, (0, target_len - curr_len), "constant")
          else:
              return arr[:target_len]
  
      max_len = (
          SAMPLES_PER_SEGMENT
          if truncate
          else max(len(wav) for wav in waveforms)
      )
      if (r := max_len % SAMPLES_PER_SEGMENT) > 0:
          max_len += SAMPLES_PER_SEGMENT - r
      waveforms = np.array(
          list(map(lambda w: pad_or_trim(w, max_len), waveforms))
      )
      assert waveforms.shape[0] <= batch_size
      if waveforms.shape[0] < batch_size:
          # we could have a symbolic batch_size dim instead of manually padding here if conv/layernorm supported symbolic shapes
          waveforms = np.pad(
              waveforms,
              pad_width=((0, batch_size - waveforms.shape[0]), (0, 0)),
          )
  
      stft = librosa.stft(
          waveforms,
          n_fft=N_FFT,
          hop_length=HOP_LENGTH,
          window="hann",
          dtype=np.csingle,
      )
      magnitudes = np.absolute(stft[..., :-1]) ** 2
      mel_spec = (
          librosa.filters.mel(sr=RATE, n_fft=N_FFT, n_mels=N_MELS)
          @ magnitudes
      )
  
      log_spec = np.log10(np.clip(mel_spec, 1e-10, None))
      log_spec = np.maximum(log_spec, log_spec.max() - 8.0)
      log_spec = (log_spec + 4.0) / 4.0
  
      return log_spec
  
imports: import sys
  import pathlib
  import base64
  import multiprocessing
  import numpy
  from typing import Optional, Union, Literal, List
  from tinygrad.jit import TinyJit
  from tinygrad.nn.state import torch_load, load_state_dict
  from tinygrad.helpers import getenv, DEBUG, CI, fetch
  import tinygrad.nn
  from tinygrad.shape.symbolic import Variable
  from tinygrad.tensor import Tensor
  import itertools
  import librosa
label_desc: Use image node_id 1 for calling a global function with example usage: prep_audio(waveforms, batch_size, truncate) and returns: log_spec, arr, np, arr