docs: def get_parser(create=True):
      """Return a parser to make that can be used to make plots or open files
      from the command line
  
      Returns
      -------
      psyplot.parser.FuncArgParser
          The :class:`argparse.ArgumentParser` instance"""
      #: The parse that is used to parse arguments from the command line
      epilog = docstrings.get_sections(docstrings.dedents("""
          Examples
          --------
  
          Here are some examples on how to use psyplot from the command line.
  
          Plot the variable ``'t2m'`` in a netCDF file ``'myfile.nc'`` and save
          the plot to ``'plot.pdf'``::
  
              $ psyplot myfile.nc -n t2m -pm mapplot -o test.pdf
  
          Create two plots for ``'t2m'`` with the first and second timestep on
          the second vertical level::
  
              $ psyplot myfile.nc -n t2m  -pm mapplot -o test.pdf -d t,0,1 z,1
  
          If you have save a project using the
          :meth:`psyplot.project.Project.save_project` method into a file named
          ``'project.pkl'``, you can replot this via::
  
              $ psyplot -p project.pkl -o test.pdf
  
          If you use a different dataset than the one you used in the project
          (e.g. ``'other_ds.nc'``), you can replace it via::
  
              $ psyplot other_dataset.nc -p project.pkl -o test.pdf
  
          or explicitly via::
  
              $ psyplot old_ds.nc,other_ds.nc -p project.pkl -o test.pdf
  
          You can also load formatoptions from a configuration file, e.g.::
  
              $ echo 'title: my title' > fmt.yaml
              $ psyplot myfile.nc -n t2m  -pm mapplot -fmt fmt.yaml -o test.pdf
          """), 'parser', ['Examples'])
  
      if _on_rtd:  # make a rubric examples section
          epilog = '.. rubric:: Examples\n' + '\n'.join(epilog.splitlines()[2:])
  
      parser = FuncArgParser(
          description="""
          Load a dataset, make the plot and save the result to a file""",
          epilog=epilog,
          formatter_class=argparse.RawDescriptionHelpFormatter)
  
      info_grp = parser.add_argument_group(
          'Info options',
          'Options that print informations and quit afterwards')
  
      parser.update_arg('version', short='V', long='version', action='version',
                        version=psyplot.__version__, if_existent=False,
                        group=info_grp)
  
      parser.update_arg('all_versions', short='aV', long='all-versions',
                        action=AllVersionsAction, if_existent=False,
                        group=info_grp)
  
      parser.update_arg('list_plugins', short='lp', long='list-plugins',
                        action=ListPluginsAction, if_existent=False,
                        group=info_grp)
      parser.update_arg(
          'list_plot_methods', short='lpm', long='list-plot-methods',
          action=ListPlotMethodsAction, if_existent=False, group=info_grp)
      parser.update_arg(
          'list_datasets', short='lds', long='list-datasets',
          action=ListDsNamesAction, if_existent=False, group=info_grp,
          help="""List the used dataset names in the given `project`.""")
  
      parser.setup_args(make_plot)
  
      output_grp = parser.add_argument_group(
          'Output options',
          'Options that only have an effect if the `-o` option is set.')
  
      parser.update_arg('fnames', positional=True, nargs='*')
  
      parser.update_arg('name', short='n', nargs='*', metavar='variable_name',
                        const=None)
  
      parser.update_arg('dims', short='d', nargs='+', type=_load_dims,
                        metavar='dim,val1[,val2[,...]]')
  
      pm_choices = {pm for pm, d in filter(
                        lambda t: t[1].get('plot_func', True),
                        six.iteritems(rcParams['project.plotters']))}
      if psyplot._project_imported:
          import psyplot.project as psy
          pm_choices.update(set(psy.plot._plot_methods))
      parser.update_arg('plot_method', short='pm', choices=pm_choices,
                        metavar='{%s}' % ', '.join(map(repr, pm_choices)))
  
      parser.update_arg('output', short='o', group=output_grp)
      parser.update_arg('output_project', short='op', group=output_grp)
  
      parser.update_arg('project', short='p')
  
      parser.update_arg(
          'formatoptions', short='fmt', type=_load_dict, help="""
          The path to a yaml (``'.yml'`` or ``'.yaml'``) or pickle file
          defining a dictionary of formatoption that is applied to the data
          visualized by the chosen `plot_method`""", metavar='FILENAME')
  
      parser.update_arg(
          'chname', type=lambda s: s.split(','), nargs='*', help="""
          A mapping from variable names in the project to variable names in the
          datasets that should be used instead. Variable names should be
          separated by a comma.""", metavar='project-variable,variable-to-use')
  
      parser.update_arg('tight', short='t', group=output_grp)
  
      parser.update_arg('rc_file', short='rc')
      parser.pop_key('rc_file', 'metavar')
  
      parser.update_arg('encoding', short='e')
  
      parser.pop_key('enable_post', 'short')
  
      parser.update_arg('seaborn_style', short='sns')
  
      parser.update_arg('concat_dim', short='cd')
  
      if create:
          parser.create_arguments()
  
      return parser