code: def run(self):  # suppress(unused-function)
          
          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)
docs: Run linters.