docs: def calendarplot(data, how='sum', yearlabels=True, yearascending=True, yearlabel_kws=None,
                   subplot_kws=None, gridspec_kws=None, fig_kws=None, **kwargs):
      """
      Plot a timeseries as a calendar heatmap.
  
      Parameters
      ----------
      data : Series
          Data for the plot. Must be indexed by a DatetimeIndex.
      how : string
          Method for resampling data by day. If `None`, assume data is already
          sampled by day and don't resample. Otherwise, this is passed to Pandas
          `Series.resample`.
      yearlabels : bool
         Whether or not to draw the year for each subplot.
      yearascending : bool
         Sort the calendar in ascending or descending order.
      yearlabel_kws : dict
         Keyword arguments passed to the matplotlib `set_ylabel` call which is
         used to draw the year for each subplot.
      subplot_kws : dict
          Keyword arguments passed to the matplotlib `add_subplot` call used to
          create each subplot.
      gridspec_kws : dict
          Keyword arguments passed to the matplotlib `GridSpec` constructor used
          to create the grid the subplots are placed on.
      fig_kws : dict
          Keyword arguments passed to the matplotlib `figure` call.
      kwargs : other keyword arguments
          All other keyword arguments are passed to `yearplot`.
  
      Returns
      -------
      fig, axes : matplotlib Figure and Axes
          Tuple where `fig` is the matplotlib Figure object `axes` is an array
          of matplotlib Axes objects with the calendar heatmaps, one per year.
  
      Examples
      --------
  
      With `calendarplot` we can plot several years in one figure:
  
      .. plot::
          :context: close-figs
  
          calmap.calendarplot(events)
  
      """
      yearlabel_kws = yearlabel_kws or {}
      subplot_kws = subplot_kws or {}
      gridspec_kws = gridspec_kws or {}
      fig_kws = fig_kws or {}
  
      years = np.unique(data.index.year)
      if not yearascending:
          years = years[::-1]
  
      fig, axes = plt.subplots(nrows=len(years), ncols=1, squeeze=False,
                               subplot_kw=subplot_kws,
                               gridspec_kw=gridspec_kws, **fig_kws)
      axes = axes.T[0]
  
      # We explicitely resample by day only once. This is an optimization.
      if how is None:
          by_day = data
      else:
          if _pandas_18:
              by_day = data.resample('D').agg(how)
          else:
              by_day = data.resample('D', how=how)
  
      ylabel_kws = dict(
          fontsize=32,
          color=kwargs.get('fillcolor', 'whitesmoke'),
          fontweight='bold',
          fontname='Arial',
          ha='center')
      ylabel_kws.update(yearlabel_kws)
  
      max_weeks = 0
  
      for year, ax in zip(years, axes):
          yearplot(by_day, year=year, how=None, ax=ax, **kwargs)
          max_weeks = max(max_weeks, ax.get_xlim()[1])
  
          if yearlabels:
              ax.set_ylabel(str(year), **ylabel_kws)
  
      # In a leap year it might happen that we have 54 weeks (e.g., 2012).
      # Here we make sure the width is consistent over all years.
      for ax in axes:
          ax.set_xlim(0, max_weeks)
  
      # Make the axes look good.
      plt.tight_layout()
  
      return fig, axes