docs: def sigma_clipped_stats(data, mask=None, mask_value=None, sigma=3.0,
                          sigma_lower=None, sigma_upper=None, maxiters=5,
                          cenfunc='median', stdfunc='std', std_ddof=0,
                          axis=None):
      """
      Calculate sigma-clipped statistics on the provided data.
  
      Parameters
      ----------
      data : array-like or `~numpy.ma.MaskedArray`
          Data array or object that can be converted to an array.
  
      mask : `numpy.ndarray` (bool), optional
          A boolean mask with the same shape as ``data``, where a `True`
          value indicates the corresponding element of ``data`` is masked.
          Masked pixels are excluded when computing the statistics.
  
      mask_value : float, optional
          A data value (e.g., ``0.0``) that is ignored when computing the
          statistics.  ``mask_value`` will be masked in addition to any
          input ``mask``.
  
      sigma : float, optional
          The number of standard deviations to use for both the lower and
          upper clipping limit.  These limits are overridden by
          ``sigma_lower`` and ``sigma_upper``, if input.  The default is
          3.
  
      sigma_lower : float or `None`, optional
          The number of standard deviations to use as the lower bound for
          the clipping limit.  If `None` then the value of ``sigma`` is
          used.  The default is `None`.
  
      sigma_upper : float or `None`, optional
          The number of standard deviations to use as the upper bound for
          the clipping limit.  If `None` then the value of ``sigma`` is
          used.  The default is `None`.
  
      maxiters : int or `None`, optional
          The maximum number of sigma-clipping iterations to perform or
          `None` to clip until convergence is achieved (i.e., iterate
          until the last iteration clips nothing).  If convergence is
          achieved prior to ``maxiters`` iterations, the clipping
          iterations will stop.  The default is 5.
  
      cenfunc : {'median', 'mean'} or callable, optional
          The statistic or callable function/object used to compute the
          center value for the clipping.  If set to ``'median'`` or
          ``'mean'`` then having the optional `bottleneck`_ package
          installed will result in the best performance.  If using a
          callable function/object and the ``axis`` keyword is used, then
          it must be callable that can ignore NaNs (e.g. `numpy.nanmean`)
          and has an ``axis`` keyword to return an array with axis
          dimension(s) removed.  The default is ``'median'``.
  
          .. _bottleneck:  https://github.com/kwgoodman/bottleneck
  
      stdfunc : {'std'} or callable, optional
          The statistic or callable function/object used to compute the
          standard deviation about the center value.  If set to ``'std'``
          then having the optional `bottleneck`_ package installed will
          result in the best performance.  If using a callable
          function/object and the ``axis`` keyword is used, then it must
          be callable that can ignore NaNs (e.g. `numpy.nanstd`) and has
          an ``axis`` keyword to return an array with axis dimension(s)
          removed.  The default is ``'std'``.
  
      std_ddof : int, optional
          The delta degrees of freedom for the standard deviation
          calculation.  The divisor used in the calculation is ``N -
          std_ddof``, where ``N`` represents the number of elements.  The
          default is 0.
  
      axis : `None` or int or tuple of int, optional
          The axis or axes along which to sigma clip the data.  If `None`,
          then the flattened data will be used.  ``axis`` is passed
          to the ``cenfunc`` and ``stdfunc``.  The default is `None`.
  
      Returns
      -------
      mean, median, stddev : float
          The mean, median, and standard deviation of the sigma-clipped
          data.
  
      See Also
      --------
      SigmaClip, sigma_clip
      """
  
      if mask is not None:
          data = np.ma.MaskedArray(data, mask)
      if mask_value is not None:
          data = np.ma.masked_values(data, mask_value)
  
      sigclip = SigmaClip(sigma=sigma, sigma_lower=sigma_lower,
                          sigma_upper=sigma_upper, maxiters=maxiters,
                          cenfunc=cenfunc, stdfunc=stdfunc)
      data_clipped = sigclip(data, axis=axis, masked=False, return_bounds=False,
                             copy=False)
  
      if HAS_BOTTLENECK:
          mean = _nanmean(data_clipped, axis=axis)
          median = _nanmedian(data_clipped, axis=axis)
          std = _nanstd(data_clipped, ddof=std_ddof, axis=axis)
      else:  # pragma: no cover
          mean = np.nanmean(data_clipped, axis=axis)
          median = np.nanmedian(data_clipped, axis=axis)
          std = np.nanstd(data_clipped, ddof=std_ddof, axis=axis)
  
      return mean, median, std