docs: def make_plot(fnames=[], name=[], dims=None, plot_method=None,
                output=None, project=None, engine=None, formatoptions=None,
                tight=False, rc_file=None, encoding=None, enable_post=False,
                seaborn_style=None, output_project=None,
                concat_dim=get_default_value(xr.open_mfdataset, 'concat_dim'),
                chname={}):
      """
      Eventually start the QApplication or only make a plot
  
      Parameters
      ----------
      fnames: list of str
          Either the filenames to show, or, if the `project` parameter is set,
          the a list of `,`-separated filenames to make a mapping from the
          original filename to a new one
      name: list of str
          The variable names to plot if the `output` parameter is set
      dims: dict
          A mapping from coordinate names to integers if the `project` is not
          given
      plot_method: str
          The name of the plot_method to use
      output: str or list of str
          If set, the data is loaded and the figures are saved to the specified
          filename and now graphical user interface is shown
      project: str
          If set, the project located at the given file name is loaded
      engine: str
          The engine to use for opening the dataset (see
          :func:`psyplot.data.open_dataset`)
      formatoptions: dict
          A dictionary of formatoption that is applied to the data visualized by
          the chosen `plot_method`
      tight: bool
          If True/set, it is tried to figure out the tight bbox of the figure and
          adjust the paper size of the `output` to it
      rc_file: str
          The path to a yaml configuration file that can be used to update  the
          :attr:`~psyplot.config.rcsetup.rcParams`
      encoding: str
          The encoding to use for loading the project. If None, it is
          automatically determined by pickle. Note: Set this to ``'latin1'``
          if using a project created with python2 on python3.
      enable_post: bool
          Enable the :attr:`~psyplot.plotter.Plotter.post` processing
          formatoption. If True/set, post processing scripts are enabled in the
          given `project`. Only set this if you are sure that you can trust the
          given project file because it may be a security vulnerability.
      seaborn_style: str
          The name of the style of the seaborn package that can be used for
          the :func:`seaborn.set_style` function
      output_project: str
          The name of a project file to save the project to
      concat_dim: str
          The concatenation dimension if multiple files in `fnames` are
          provided
      chname: dict
          A mapping from variable names in the project to variable names in the
          datasets that should be used instead
      """
      if project is not None and (name != [] or dims is not None):
          warn('The `name` and `dims` parameter are ignored if the `project`'
               ' parameter is set!')
      if rc_file is not None:
          rcParams.load_from_file(rc_file)
  
      if dims is not None and not isinstance(dims, dict):
          dims = dict(chain(*map(six.iteritems, dims)))
  
      if len(output) == 1:
          output = output[0]
      if not fnames and not project:
          raise ValueError(
              "Either a filename or a project file must be provided if "
              "the output parameter is set!")
      elif project is None and plot_method is None:
          raise ValueError(
              "A plotting method must be provided if the output parameter "
              "is set and not the project!")
      if seaborn_style is not None:
          import seaborn as sns
          sns.set_style(seaborn_style)
      import psyplot.project as psy
      if project is not None:
          fnames = [s.split(',') for s in fnames]
          chname = dict(chname)
          single_files = (l[0] for l in fnames if len(l) == 1)
          alternative_paths = defaultdict(lambda: next(single_files, None))
          alternative_paths.update([l for l in fnames if len(l) == 2])
          p = psy.Project.load_project(
              project, alternative_paths=alternative_paths,
              engine=engine, encoding=encoding, enable_post=enable_post,
              chname=chname)
          if formatoptions is not None:
              p.update(fmt=formatoptions)
          p.export(output, tight=tight)
      else:
          pm = getattr(psy.plot, plot_method, None)
          if pm is None:
              raise ValueError("Unknown plot method %s!" % plot_method)
          kwargs = {'name': name} if name else {}
          p = pm(
              fnames, dims=dims or {}, engine=engine,
              fmt=formatoptions or {}, mf_mode=True, concat_dim=concat_dim,
              **kwargs)
          p.export(output, tight=tight)
      if output_project is not None:
          p.save_project(output_project)
      return