class_docstr: Forecaster that plays back known or prescribed values as forecasts.
  
  Takes a data set of "known future values" to produces these in the sktime interface.
  
  Common use cases for this forecaster:
  
  * as a dummy or naive forecaster with a known baseline expectation
  * as a forecaster with (non-naive) expert forecasts, "known" values as per expert
  * as a counterfactual in benchmarking experiments, "what if we knew the truth"
  * to pass forecast data values in a composite used for postprocessing,
    e.g., in combination with ReconcilerForecaster for an isolated reconciliation step
  
  When forecasting, uses `pandas.DataFrame.reindex` under the hood to obtain predicted
  values from `y_known`. Parameters other than `y_known` are directly passed
  on to `pandas.DataFrame.reindex`.
  
  Parameters
  ----------
  y_known : pd.DataFrame or pd.Series in one of the sktime compatible data formats
      should contain known values that the forecaster will replay in predict
      can also be in a non-pandas sktime data format, will then be coerced to pandas
  method : str or None, optional, default=None
      one of {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}
      method to use for imputing indices at which forecasts are unavailable in y_known
  fill_value : scalar, optional, default=np.NaN
      value to use for any missing values (e.g., if `method` is None)
  limit : int, optional, default=None=infinite
      maximum number of consecutive elements to bfill/ffill if `method=bfill`/`ffill`
  
  Examples
  --------
  >>> y_known = pd.DataFrame(range(100))
  >>> y_train = y_known[:24]
  >>>
  >>> from sktime.forecasting.dummy import ForecastKnownValues
  >>>
  >>> fcst = ForecastKnownValues(y_known)
  >>> fcst.fit(y_train, fh=[1, 2, 3])
  ForecastKnownValues(...)
  
  The forecast "plays back" the known/prescribed values from y_known
  
  >>> y_pred = fcst.predict()
code: def __init__(self, y_known, method=None, fill_value=None, limit=None):
      self.y_known = y_known
      self.method = method
      self.fill_value = fill_value
      self.limit = limit
  
      super().__init__()
  
      PANDAS_DF_TYPES = [
          "pd.DataFrame",
          "pd-multiindex",
          "pd_multiindex_hier",
      ]
  
      self._y_known = convert_to(y_known, PANDAS_DF_TYPES)
  
      idx = self._y_known.index
      if isinstance(idx, pd.MultiIndex):
          if idx.nlevels >= 3:
              mtypes = [
                  "pd.DataFrame",
                  "pd-multiindex",
                  "pd_multiindex_hier",
              ]
          elif idx.nlevels == 2:
              mtypes = ["pd.DataFrame", "pd-multiindex"]
          self.set_tags(**{"y_inner_mtype": mtypes})
          self.set_tags(**{"X_inner_mtype": mtypes})
  
file_path: sktime/sktime/forecasting/dummy.py
imports: import pandas
  from sktime.datatypes import convert_to
  from sktime.forecasting.base import BaseForecaster
label_desc: Use image node_id 1 to create a new ForecastKnownValues object from inherited base classes: BaseForecaster with example: obj = ForecastKnownValues(y_known, method, fill_value, limit)