docs: def hist(hists,
           stacked=True,
           reverse=False,
           xpadding=0, ypadding=.1,
           yerror_in_padding=True,
           logy=None,
           snap=True,
           axes=None,
           **kwargs):
      """
      Make a matplotlib hist plot from a ROOT histogram, stack or
      list of histograms.
  
      Parameters
      ----------
  
      hists : Hist, list of Hist, HistStack
          The histogram(s) to be plotted
  
      stacked : bool, optional (default=True)
          If True then stack the histograms with the first histogram on the
          bottom, otherwise overlay them with the first histogram in the
          background.
  
      reverse : bool, optional (default=False)
          If True then reverse the order of the stack or overlay.
  
      xpadding : float or 2-tuple of floats, optional (default=0)
          Padding to add on the left and right sides of the plot as a fraction of
          the axes width after the padding has been added. Specify unique left
          and right padding with a 2-tuple.
  
      ypadding : float or 2-tuple of floats, optional (default=.1)
          Padding to add on the top and bottom of the plot as a fraction of
          the axes height after the padding has been added. Specify unique top
          and bottom padding with a 2-tuple.
  
      yerror_in_padding : bool, optional (default=True)
          If True then make the padding inclusive of the y errors otherwise
          only pad around the y values.
  
      logy : bool, optional (default=None)
          Apply special treatment of a log-scale y-axis to display the histogram
          correctly. If None (the default) then automatically determine if the
          y-axis is log-scale.
  
      snap : bool, optional (default=True)
          If True (the default) then the origin is an implicit lower bound of the
          histogram unless the histogram has both positive and negative bins.
  
      axes : matplotlib Axes instance, optional (default=None)
          The axes to plot on. If None then use the global current axes.
  
      kwargs : additional keyword arguments, optional
          All additional keyword arguments are passed to matplotlib's
          fill_between for the filled regions and matplotlib's step function
          for the edges.
  
      Returns
      -------
  
      The return value from matplotlib's hist function, or list of such return
      values if a stack or list of histograms was plotted.
  
      """
      if axes is None:
          axes = plt.gca()
      if logy is None:
          logy = axes.get_yscale() == 'log'
      curr_xlim = axes.get_xlim()
      curr_ylim = axes.get_ylim()
      was_empty = not axes.has_data()
      returns = []
      if isinstance(hists, _Hist):
          # This is a single plottable object.
          returns = _hist(hists, axes=axes, logy=logy, **kwargs)
          _set_bounds(hists, axes=axes,
                      was_empty=was_empty,
                      prev_xlim=curr_xlim,
                      prev_ylim=curr_ylim,
                      xpadding=xpadding, ypadding=ypadding,
                      yerror_in_padding=yerror_in_padding,
                      snap=snap,
                      logy=logy)
      elif stacked:
          # draw the top histogram first so its edges don't cover the histograms
          # beneath it in the stack
          if not reverse:
              hists = list(hists)[::-1]
          for i, h in enumerate(hists):
              kwargs_local = kwargs.copy()
              if i == len(hists) - 1:
                  low = h.Clone()
                  low.Reset()
              else:
                  low = sum(hists[i + 1:])
              high = h + low
              high.alpha = getattr(h, 'alpha', None)
              proxy = _hist(high, bottom=low, axes=axes, logy=logy, **kwargs)
              returns.append(proxy)
          if not reverse:
              returns = returns[::-1]
          _set_bounds(sum(hists), axes=axes,
                      was_empty=was_empty,
                      prev_xlim=curr_xlim,
                      prev_ylim=curr_ylim,
                      xpadding=xpadding, ypadding=ypadding,
                      yerror_in_padding=yerror_in_padding,
                      snap=snap,
                      logy=logy)
      else:
          for h in _maybe_reversed(hists, reverse):
              returns.append(_hist(h, axes=axes, logy=logy, **kwargs))
          if reverse:
              returns = returns[::-1]
          _set_bounds(hists[max(range(len(hists)), key=lambda idx: hists[idx].max())],
                      axes=axes,
                      was_empty=was_empty,
                      prev_xlim=curr_xlim,
                      prev_ylim=curr_ylim,
                      xpadding=xpadding, ypadding=ypadding,
                      yerror_in_padding=yerror_in_padding,
                      snap=snap,
                      logy=logy)
      return returns