code: def trim(
      y: np.ndarray,
      *,
      top_db: float = 60,
      ref: Union[float, Callable] = np.max,
      frame_length: int = 2048,
      hop_length: int = 512,
      aggregate: Callable = np.max,
  ) -> Tuple[np.ndarray, np.ndarray]:
      """Trim leading and trailing silence from an audio signal.
  
      Parameters
      ----------
      y : np.ndarray, shape=(..., n)
          Audio signal. Multi-channel is supported.
      top_db : number > 0
          The threshold (in decibels) below reference to consider as
          silence
      ref : number or callable
          The reference amplitude.  By default, it uses `np.max` and compares
          to the peak amplitude in the signal.
      frame_length : int > 0
          The number of samples per analysis frame
      hop_length : int > 0
          The number of samples between analysis frames
      aggregate : callable [default: np.max]
          Function to aggregate across channels (if y.ndim > 1)
  
      Returns
      -------
      y_trimmed : np.ndarray, shape=(..., m)
          The trimmed signal
      index : np.ndarray, shape=(2,)
          the interval of ``y`` corresponding to the non-silent region:
          ``y_trimmed = y[index[0]:index[1]]`` (for mono) or
          ``y_trimmed = y[:, index[0]:index[1]]`` (for stereo).
  
      Examples
      --------
      >>> # Load some audio
      >>> y, sr = librosa.load(librosa.ex('choice'))
      >>> # Trim the beginning and ending silence
      >>> yt, index = librosa.effects.trim(y)
      >>> # Print the durations
      >>> print(librosa.get_duration(y), librosa.get_duration(yt))
      25.025986394557822 25.007891156462584
      """
      non_silent = _signal_to_frame_nonsilent(
          y,
          frame_length=frame_length,
          hop_length=hop_length,
          ref=ref,
          top_db=top_db,
          aggregate=aggregate,
      )
  
      nonzero = np.flatnonzero(non_silent)
  
      if nonzero.size > 0:
          # Compute the start and end positions
          # End position goes one frame past the last non-zero
          start = int(
              core.frames_to_samples(nonzero[0], hop_length=hop_length)
          )
          end = min(
              y.shape[-1],
              int(
                  core.frames_to_samples(
                      nonzero[-1] + 1, hop_length=hop_length
                  )
              ),
          )
      else:
          # The signal only contains zeros
          start, end = 0, 0
  
      # Build the mono/stereo index
      full_index = [slice(None)] * y.ndim
      full_index[-1] = slice(start, end)
  
      return y[tuple(full_index)], np.asarray([start, end])
  
imports: import numpy
  import scipy.signal
  from .None import core
  from .None import decompose
  from .None import feature
  from .None import util
  from .util.exceptions import ParameterError
  from typing import Any, Callable, Iterable, Optional, Tuple, Union, overload
  from typing_extensions import Literal
  from numpy.typing import ArrayLike
label_desc: Use image node_id 8 for calling a global function with example usage: trim(y) and returns: y,  np