code: def plot_predicted_components(
      predicted_df,
      date_col,
      prediction_percentiles=None,
      plot_components=None,
      title="",
      figsize=None,
      path=None,
      fontsize=None,
      is_visible=True,
  ):
      """Plot predicted components with the data frame of decomposed prediction where components
       has been pre-defined as `trend`, `seasonality` and `regression`.
  
       Parameters
       ----------
       predicted_df : pd.DataFrame
           predicted data response data frame. two columns required: actual_col and pred_col. If
           user provide pred_percentiles_col, it needs to include them as well.
       date_col : str
           the date column name
       prediction_percentiles : list
           a list should consist exact two elements which will be used to plot as lower and upper bound of
           confidence interval
       plot_components : list
           a list of strings to show the label of components to be plotted; by default, it uses values in
           `orbit.constants.constants.PredictedComponents`.
       title : str; optional
           title of the plot
       figsize : tuple; optional
           figsize pass through to `matplotlib.pyplot.figure()`
       path : str; optional
           path to save the figure
       fontsize : int; optional
           fontsize of the title
       is_visible : boolean
           whether we want to show the plot. If called from unittest, is_visible might = False.
  
      Returns
      -------
           matplotlib axes object
      """
  
      _predicted_df = predicted_df.copy()
      _predicted_df[date_col] = pd.to_datetime(_predicted_df[date_col])
      if plot_components is None:
          plot_components = [
              PredictionKeys.TREND.value,
              PredictionKeys.SEASONALITY.value,
              PredictionKeys.REGRESSION.value,
          ]
  
      plot_components = [
          p
          for p in plot_components
          if p in _predicted_df.columns.tolist()
      ]
      nrows = len(plot_components)
      if not figsize:
          figsize = (16, 8)
  
      if not fontsize:
          fontsize = 16
  
      if prediction_percentiles is None:
          _pred_percentiles = [5, 95]
      else:
          _pred_percentiles = prediction_percentiles
  
      if len(_pred_percentiles) != 2:
          raise ValueError(
              "prediction_percentiles has to be None or a list with length=2."
          )
  
      fig, axes = plt.subplots(
          nrows=nrows, ncols=1, figsize=figsize, squeeze=False
      )
      axes = axes.flatten()
      for ax, comp in zip(axes, plot_components):
          y = predicted_df[comp].values
          ax.plot(
              _predicted_df[date_col],
              y,
              marker=None,
              color=PredPal.PREDICTION_INTERVAL.value,
          )
          confid_cols = [
              "{}_{}".format(comp, _pred_percentiles[0]),
              "{}_{}".format(comp, _pred_percentiles[1]),
          ]
          if set(confid_cols).issubset(predicted_df.columns):
              ax.fill_between(
                  _predicted_df[date_col].values,
                  _predicted_df[confid_cols[0]],
                  _predicted_df[confid_cols[1]],
                  facecolor=PredPal.PREDICTION_INTERVAL.value,
                  alpha=0.3,
              )
          ax.set_title(comp, fontsize=fontsize)
  
      plt.suptitle(title, fontsize=fontsize)
      fig.tight_layout()
  
      if path:
          plt.savefig(path)
      if is_visible:
          plt.show()
      else:
          plt.close()
  
      return axes
  
imports: import matplotlib.pyplot
  import seaborn
  import pandas
  import numpy
  import math
  import os
  import pkg_resources
  import statsmodels.api
  from scipy import stats
  from ..constants.constants import PredictionKeys
  from orbit.utils.general import is_empty_dataframe, is_ordered_datetime
  from ..constants.constants import BacktestFitKeys
  from ..constants.palette import PredictionPaletteClassic
  from orbit.constants import palette
  from orbit.diagnostics.metrics import smape
  from orbit.utils.plot import orbit_style_decorator
  from ..exceptions import PlotException
  import logging
label_desc: Use image node_id 2 for calling a global function with example usage: plot_predicted_components(predicted_df, date_col, prediction_percentiles, plot_components, title, figsize, path, fontsize, is_visible) and returns: axes