docs: def load_plugins(self, raise_error=False):
          """
          Load the plotters and defaultParams from the plugins
  
          This method loads the `plotters` attribute and `defaultParams`
          attribute from the plugins that use the entry point specified by
          `group`. Entry points must be objects (or modules) that have a
          `defaultParams` and a `plotters` attribute.
  
          Parameters
          ----------
          raise_error: bool
              If True, an error is raised when multiple plugins define the same
              plotter or rcParams key. Otherwise only a warning is raised"""
  
          pm_env = os.getenv('PSYPLOT_PLOTMETHODS', '').split('::')
          include_pms = [s[4:] for s in pm_env if s.startswith('yes:')]
          exclude_pms = [s[3:] for s in pm_env if s.startswith('no:')]
  
          logger = logging.getLogger(__name__)
  
          plotters = self['project.plotters']
          def_plots = {'default': list(plotters)}
          defaultParams = self.defaultParams
          def_keys = {'default': defaultParams}
  
          def register_pm(ep, name):
              full_name = '%s:%s' % (ep.module_name, name)
              ret = True
              if pm_env == ['no']:
                  ret = False
              elif name in exclude_pms or full_name in exclude_pms:
                  ret = False
              elif include_pms and (name not in include_pms and
                                    full_name not in include_pms):
                  ret = False
              if not ret:
                  logger.debug('Skipping plot method %s', full_name)
              return ret
  
          for ep in self._load_plugin_entrypoints():
              plugin_mod = ep.load()
              rc = plugin_mod.rcParams
  
              # load the plotters
              plugin_plotters = {
                  key: val for key, val in rc.get('project.plotters', {}).items()
                  if register_pm(ep, key)}
              already_defined = set(plotters).intersection(plugin_plotters)
              if already_defined:
                  msg = ("Error while loading psyplot plugin %s! The "
                         "following plotters have already been "
                         "defined") % ep
                  msg += 'and will be overwritten:' if not raise_error else ':'
                  msg += '\n' + '\n'.join(chain.from_iterable(
                      (('%s by %s' % (key, plugin)
                        for plugin, keys in def_plots.items() if key in keys)
                       for key in already_defined)))
                  if raise_error:
                      raise ImportError(msg)
                  else:
                      warn(msg)
              for d in plugin_plotters.values():
                  d['plugin'] = ep.module_name
              plotters.update(plugin_plotters)
              def_plots[ep] = list(plugin_plotters)
  
              # load the defaultParams keys
              plugin_defaultParams = rc.defaultParams
              already_defined = set(defaultParams).intersection(
                  plugin_defaultParams) - {'project.plotters'}
              if already_defined:
                  msg = ("Error while loading psyplot plugin %s! The "
                         "following default keys have already been "
                         "defined:") % ep
                  msg += '\n' + '\n'.join(chain.from_iterable(
                      (('%s by %s' % (key, plugin)
                        for plugin, keys in def_keys.items() if key in keys)
                       for key in already_defined)))
                  if raise_error:
                      raise ImportError(msg)
                  else:
                      warn(msg)
              update_keys = set(plugin_defaultParams) - {'project.plotters'}
              def_keys[ep] = update_keys
              self.defaultParams.update(
                  {key: plugin_defaultParams[key] for key in update_keys})
  
              # load the rcParams (without validation)
              super(RcParams, self).update({key: rc[key] for key in update_keys})
  
              # add the deprecated keys
              self._deprecated_ignore_map.update(rc._deprecated_ignore_map)
              self._deprecated_map.update(rc._deprecated_map)