Run linters.

def run(self):  # suppress(unused-function)
        """Run linters."""
        import parmap
        from prospector.formatters.pylint import PylintFormatter

        cwd = os.getcwd()
        files = self._get_files_to_lint([os.path.join(cwd, "test")])

        if not files:
            sys_exit(0)
            return

        use_multiprocessing = (not os.getenv("DISABLE_MULTIPROCESSING",
                                             None) and
                               multiprocessing.cpu_count() < len(files) and
                               multiprocessing.cpu_count() > 2)

        if use_multiprocessing:
            mapper = parmap.map
        else:
            # suppress(E731)
            mapper = lambda f, i, *a: [f(*((x, ) + a)) for x in i]

        with _patched_pep257():
            keyed_messages = dict()

            # Certain checks, such as vulture and pyroma cannot be
            # meaningfully run in parallel (vulture requires all
            # files to be passed to the linter, pyroma can only be run
            # on /setup.py, etc).
            non_test_files = [f for f in files if not _file_is_test(f)]
            if self.stamp_directory:
                stamp_directory = self.stamp_directory
            else:
                stamp_directory = os.path.join(self.cache_directory,
                                               "polysquare_setuptools_lint",
                                               "jobstamps")

            # This will ensure that we don't repeat messages, because
            # new keys overwrite old ones.
            for keyed_subset in self._map_over_linters(files,
                                                       non_test_files,
                                                       self._get_md_files(),
                                                       stamp_directory,
                                                       mapper):
                keyed_messages.update(keyed_subset)

        messages = []
        for _, message in keyed_messages.items():
            if not self._suppressed(message.location.path,
                                    message.location.line,
                                    message.code):
                message.to_relative_path(cwd)
                messages.append(message)

        sys.stdout.write(PylintFormatter(dict(),
                                         messages,
                                         None).render(messages=True,
                                                      summary=False,
                                                      profile=False) + "\n")

        if messages:
            sys_exit(1)