def info(self, exp_path=False, project_path=False, global_path=False,
             config_path=False, complete=False, no_fix=False,
             on_projects=False, on_globals=False, projectname=None,
             return_dict=False, insert_id=True, only_keys=False,
             archives=False, **kwargs):
        """
        Print information on the experiments

        Parameters
        ----------
        exp_path: bool
            If True/set, print the filename of the experiment configuration
        project_path: bool
            If True/set, print the filename on the project configuration
        global_path: bool
            If True/set, print the filename on the global configuration
        config_path: bool
            If True/set, print the path to the configuration directory
        complete: bool
            If True/set, the information on all experiments are printed
        no_fix: bool
            If set, paths are given relative to the root directory of the
            project
        on_projects: bool
            If set, show information on the projects rather than the
            experiment
        on_globals: bool
            If set, show the global configuration settings
        projectname: str
            The name of the project that shall be used. If provided and
            `on_projects` is not True, the information on all experiments for
            this project will be shown
        return_dict: bool
            If True, the dictionary is returned instead of printed
        insert_id: bool
            If True and neither `on_projects`, nor `on_globals`, nor
            `projectname` is given, the experiment id is inserted in the
            dictionary
        only_keys: bool
            If True, only the keys of the given dictionary are printed
        archives: bool
            If True, print the archives and the corresponding experiments for
            the specified project
        """
        self.app_main(**kwargs)

        def get_archives(project):
            ret = OrderedDict()
            for exp, a in self.config.experiments.items():
                if self.is_archived(exp) and a.project == project:
                    ret.setdefault(str(a), []).append(exp)
            return ret

        paths = OrderedDict([
            ('conf_dir', config_path), ('_globals_file', global_path)])
        if any(paths.values()):
            for key, val in paths.items():
                if val:
                    return (self.print_ or six.print_)(getattr(
                        self.config, key))
            return
        if archives:
            base = OrderedDict()
            current = projectname or self.projectname
            if complete:
                for project in self.config.projects.keys():
                    d = get_archives(project)
                    if d:
                        base[project] = d
            else:
                base[current] = get_archives(current)
        elif exp_path:
            current = self.experiment
            base = self.config.experiments.exp_files
        elif project_path:
            current = self.projectname
            base = OrderedDict(
                (key, osp.join(val, '.project', '.project.yml'))
                for key, val in self.config.projects.project_paths.items())
        elif on_globals:
            complete = True
            no_fix = True
            base = self.config.global_config
        elif on_projects:
            base = OrderedDict(self.config.projects)
            current = projectname or self.projectname
        else:
            current = self.experiment
            if projectname is None:
                if insert_id:
                    base = copy.deepcopy(self.config.experiments)
                    if not complete:
                        base[current]['id'] = current
                        if six.PY3:
                            base[current].move_to_end('id', last=False)
                else:
                    base = self.config.experiments
                if not only_keys:
                    # make sure the experiments are loaded
                    if complete:
                        base.load()
                    else:
                        base[current]
                # convert to an OrderedDict
                base = base.as_ordereddict()
            else:
                base = OrderedDict(
                    (exp, self.config.experiments[exp])
                    for exp in self.config.experiments.project_map[projectname]
                    )
                complete = True

        if no_fix and not (archives or on_globals):
            for key, val in base.items():
                if isinstance(val, dict):
                    base[key] = self.rel_paths(copy.deepcopy(val))
        if not complete:
            base = base[current]
        if only_keys:
            base = list(base.keys())
        if not return_dict:
            if isinstance(base, six.string_types):
                ret = base
            else:
                ret = ordered_yaml_dump(base, default_flow_style=False)
            return (self.print_ or six.print_)(ret.rstrip())
        else:
            return base