docs: def smooth(x, window_len=7, window='hanning'):
      """
      Smooth the data in x using convolution with a window of requested
      size and type.
  
      Parameters
      ----------
      x : array_like(float)
          A flat NumPy array containing the data to smooth
      window_len : scalar(int), optional
          An odd integer giving the length of the window.  Defaults to 7.
      window : string
          A string giving the window type. Possible values are 'flat',
          'hanning', 'hamming', 'bartlett' or 'blackman'
  
      Returns
      -------
      array_like(float)
          The smoothed values
  
      Notes
      -----
      Application of the smoothing window at the top and bottom of x is
      done by reflecting x around these points to extend it sufficiently
      in each direction.
  
      """
      if len(x) < window_len:
          raise ValueError("Input vector length must be >= window length.")
  
      if window_len < 3:
          raise ValueError("Window length must be at least 3.")
  
      if not window_len % 2:  # window_len is even
          window_len += 1
          print("Window length reset to {}".format(window_len))
  
      windows = {'hanning': np.hanning,
                 'hamming': np.hamming,
                 'bartlett': np.bartlett,
                 'blackman': np.blackman,
                 'flat': np.ones  # moving average
                 }
  
      # === Reflect x around x[0] and x[-1] prior to convolution === #
      k = int(window_len / 2)
      xb = x[:k]   # First k elements
      xt = x[-k:]  # Last k elements
      s = np.concatenate((xb[::-1], x, xt[::-1]))
  
      # === Select window values === #
      if window in windows.keys():
          w = windows[window](window_len)
      else:
          msg = "Unrecognized window type '{}'".format(window)
          print(msg + " Defaulting to hanning")
          w = windows['hanning'](window_len)
  
      return np.convolve(w / w.sum(), s, mode='valid')