prospector 1.12.0__py3-none-any.whl → 1.13.0__py3-none-any.whl

prospector/tools/pylint/__init__.py

@@ -2,8 +2,9 @@ import os
 import re
 import sys
 from collections import defaultdict
+from collections.abc import Iterable
 from pathlib import Path
-from typing import List
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from pylint.config import find_default_config_files
 from pylint.exceptions import UnknownMessageError
@@ -15,6 +16,9 @@ from prospector.tools.base import ToolBase
 from prospector.tools.pylint.collector import Collector
 from prospector.tools.pylint.linter import ProspectorLinter
 
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
 _UNUSED_WILDCARD_IMPORT_RE = re.compile(r"^Unused import(\(s\))? (.*) from wildcard import")
 
 
@@ -27,12 +31,13 @@ class PylintTool(ToolBase):
     # be functions (they don't use the 'self' argument) but that would
     # make this module/class a bit ugly.
 
-    def __init__(self):
-        self._args = None
-        self._collector = self._linter = None
-        self._orig_sys_path = []
+    def __init__(self) -> None:
+        self._args: Any = None
+        self._collector: Optional[Collector] = None
+        self._linter: Optional[ProspectorLinter] = None
+        self._orig_sys_path: list[str] = []
 
-    def _prospector_configure(self, prospector_config, linter: ProspectorLinter):
+    def _prospector_configure(self, prospector_config: "ProspectorConfig", linter: ProspectorLinter) -> list[Message]:
         errors = []
 
         if "django" in prospector_config.libraries:
@@ -43,14 +48,14 @@ class PylintTool(ToolBase):
             linter.load_plugin_modules(["pylint_flask"])
 
         profile_path = os.path.join(prospector_config.workdir, prospector_config.profile.name)
-        for plugin in prospector_config.profile.pylint.get("load-plugins", []):
+        for plugin in prospector_config.profile.pylint.get("load-plugins", []):  # type: ignore[attr-defined]
             try:
                 linter.load_plugin_modules([plugin])
             except ImportError:
                 errors.append(self._error_message(profile_path, f"Could not load plugin {plugin}"))
 
         for msg_id in prospector_config.get_disabled_messages("pylint"):
-            try:
+            try:  # noqa: SIM105
                 linter.disable(msg_id)
             except UnknownMessageError:
                 # If the msg_id doesn't exist in PyLint any more,
@@ -64,7 +69,9 @@ class PylintTool(ToolBase):
                 continue
             for option in checker.options:
                 if option[0] in options:
-                    checker._arguments_manager.set_option(option[0], options[option[0]])
+                    checker._arguments_manager.set_option(  # pylint: disable=protected-access
+                        option[0], options[option[0]]
+                    )
 
         # The warnings about disabling warnings are useful for figuring out
         # with other tools to suppress messages from. For example, an unused
@@ -82,16 +89,17 @@ class PylintTool(ToolBase):
             if not hasattr(checker, "options"):
                 continue
             for option in checker.options:
-                if max_line_length is not None:
-                    if option[0] == "max-line-length":
-                        checker.set_option("max-line-length", max_line_length)
+                if max_line_length is not None and option[0] == "max-line-length":
+                    checker._arguments_manager.set_option(  # pylint: disable=protected-access
+                        "max-line-length", max_line_length
+                    )
         return errors
 
-    def _error_message(self, filepath, message):
+    def _error_message(self, filepath: Union[str, Path], message: str) -> Message:
         location = Location(filepath, None, None, 0, 0)
         return Message("prospector", "config-problem", location, message)
 
-    def _pylintrc_configure(self, pylintrc, linter):
+    def _pylintrc_configure(self, pylintrc: Union[str, Path], linter: ProspectorLinter) -> list[Message]:
         errors = []
         are_plugins_loaded = linter.config_from_file(pylintrc)
         if not are_plugins_loaded and hasattr(linter.config, "load_plugins"):
@@ -102,7 +110,9 @@ class PylintTool(ToolBase):
                     errors.append(self._error_message(pylintrc, f"Could not load plugin {plugin}"))
         return errors
 
-    def configure(self, prospector_config, found_files: FileFinder):
+    def configure(
+        self, prospector_config: "ProspectorConfig", found_files: FileFinder
+    ) -> Optional[tuple[Optional[Union[str, Path]], Optional[Iterable[Message]]]]:
         extra_sys_path = found_files.make_syspath()
         check_paths = self._get_pylint_check_paths(found_files)
 
@@ -127,13 +137,13 @@ class PylintTool(ToolBase):
         self._linter = linter
         return configured_by, config_messages
 
-    def _set_path_finder(self, extra_sys_path: List[Path], pylint_options):
+    def _set_path_finder(self, extra_sys_path: list[Path], pylint_options: dict[str, Any]) -> None:
         # insert the target path into the system path to get correct behaviour
         self._orig_sys_path = sys.path
         if not pylint_options.get("use_pylint_default_path_finder"):
             sys.path = sys.path + [str(path.absolute()) for path in extra_sys_path]
 
-    def _get_pylint_check_paths(self, found_files: FileFinder) -> List[Path]:
+    def _get_pylint_check_paths(self, found_files: FileFinder) -> list[Path]:
         # create a list of packages, but don't include packages which are
         # subpackages of others as checks will be duplicated
         check_paths = set()
@@ -165,17 +175,21 @@ class PylintTool(ToolBase):
         return sorted(check_paths)
 
     def _get_pylint_configuration(
-        self, check_paths: List[Path], linter: ProspectorLinter, prospector_config, pylint_options
-    ):
+        self,
+        check_paths: list[Path],
+        linter: ProspectorLinter,
+        prospector_config: "ProspectorConfig",
+        pylint_options: dict[str, Any],
+    ) -> tuple[list[Message], Optional[Union[Path, str]]]:
         self._args = check_paths
         linter.load_default_plugins()
 
-        config_messages = self._prospector_configure(prospector_config, linter)
-        configured_by = None
+        config_messages: list[Message] = self._prospector_configure(prospector_config, linter)
+        configured_by: Optional[Union[str, Path]] = None
 
         if prospector_config.use_external_config("pylint"):
-            # try to find a .pylintrc
-            pylintrc = pylint_options.get("config_file")
+            # Try to find a .pylintrc
+            pylintrc: Optional[Union[str, Path]] = pylint_options.get("config_file")
             external_config = prospector_config.external_config_location("pylint")
 
             pylintrc = pylintrc or external_config
@@ -201,7 +215,7 @@ class PylintTool(ToolBase):
 
         return config_messages, configured_by
 
-    def _combine_w0614(self, messages):
+    def _combine_w0614(self, messages: list[Message]) -> list[Message]:
         """
         For the "unused import from wildcard import" messages,
         we want to combine all warnings about the same line into
@@ -219,15 +233,17 @@ class PylintTool(ToolBase):
         for location, message_list in by_loc.items():
             names = []
             for msg in message_list:
-                names.append(_UNUSED_WILDCARD_IMPORT_RE.match(msg.message).group(1))
+                match_ = _UNUSED_WILDCARD_IMPORT_RE.match(msg.message)
+                assert match_ is not None
+                names.append(match_.group(1))
 
-            msgtxt = "Unused imports from wildcard import: %s" % ", ".join(names)
+            msgtxt = "Unused imports from wildcard import: {}".format(", ".join(names))
             combined_message = Message("pylint", "unused-wildcard-import", location, msgtxt)
             out.append(combined_message)
 
         return out
 
-    def combine(self, messages):
+    def combine(self, messages: list[Message]) -> list[Message]:
         """
         Combine repeated messages.
 
@@ -241,7 +257,10 @@ class PylintTool(ToolBase):
         combined = self._combine_w0614(messages)
         return sorted(combined)
 
-    def run(self, found_files) -> List[Message]:
+    def run(self, found_files: FileFinder) -> list[Message]:
+        assert self._collector is not None
+        assert self._linter is not None
+
         self._linter.check(self._args)
         sys.path = self._orig_sys_path
 

prospector/tools/pylint/collector.py

@@ -3,6 +3,7 @@ from typing import List
 
 from pylint.exceptions import UnknownMessageError
 from pylint.message import Message as PylintMessage
+from pylint.message import MessageDefinitionStore
 from pylint.reporters import BaseReporter
 
 from prospector.message import Location, Message
@@ -11,10 +12,10 @@ from prospector.message import Location, Message
 class Collector(BaseReporter):
     name = "collector"
 
-    def __init__(self, message_store):
+    def __init__(self, message_store: MessageDefinitionStore) -> None:
         BaseReporter.__init__(self, output=StringIO())
         self._message_store = message_store
-        self._messages = []
+        self._messages: list[Message] = []
 
     def handle_message(self, msg: PylintMessage) -> None:
         loc = Location(msg.abspath, msg.module, msg.obj, msg.line, msg.column)
@@ -34,8 +35,5 @@ class Collector(BaseReporter):
         message = Message("pylint", msg_symbol, loc, msg.msg)
         self._messages.append(message)
 
-    def _display(self, layout) -> None:
-        pass
-
     def get_messages(self) -> List[Message]:
         return self._messages

prospector/tools/pylint/linter.py

@@ -1,72 +1,39 @@
+from collections.abc import Iterable
 from pathlib import Path
+from typing import Any, Optional, Union
 
 from packaging import version as packaging_version
 from pylint import version as pylint_version
-from pylint.config.config_file_parser import _ConfigurationFileParser
-from pylint.config.config_initialization import _order_all_first
+from pylint.config.config_initialization import _config_initialization
 from pylint.lint import PyLinter
-from pylint.utils import _splitstrip, utils
+
+from prospector.finder import FileFinder
+
+
+class UnrecognizedOptions(Exception):
+    """Raised when an unrecognized option is found in the Pylint configuration."""
 
 
 class ProspectorLinter(PyLinter):
-    def __init__(self, found_files, *args, **kwargs):
+    def __init__(self, found_files: FileFinder, *args: Any, **kwargs: Any) -> None:
         self._files = found_files
         # set up the standard PyLint linter
         PyLinter.__init__(self, *args, **kwargs)
 
     # Largely inspired by https://github.com/pylint-dev/pylint/blob/main/pylint/config/config_initialization.py#L26
-    def config_from_file(self, config_file=None):
-        """Will return `True` if plugins have been loaded. For pylint>=1.5. Else `False`."""
-        config_file_parser = _ConfigurationFileParser(False, self)
-        config_data, config_args = config_file_parser.parse_config_file(file_path=config_file)
-        if config_data.get("MASTER", {}).get("load-plugins"):
-            plugins = _splitstrip(config_data["MASTER"]["load-plugins"])
-            self.load_plugin_modules(plugins)
-
-        config_args = _order_all_first(config_args, joined=False)
-
-        if "init-hook" in config_data:
-            exec(utils._unquote(config_data["init-hook"]))  # pylint: disable=exec-used
-
-        # Load plugins if specified in the config file
-        if "load-plugins" in config_data:
-            self.load_plugin_modules(utils._splitstrip(config_data["load-plugins"]))
-
-        self._parse_configuration_file(config_args)
-
-        # Set the current module to the command line
-        # to allow raising messages on it
-        self.set_current_module(config_file)
-
-        self._emit_stashed_messages()
-
-        # Set the current module to configuration as we don't know where
-        # the --load-plugins key is coming from
-        self.set_current_module("Command line or configuration file")
-
-        # We have loaded configuration from config file and command line. Now, we can
-        # load plugin specific configuration.
-        self.load_plugin_configuration()
-
-        # Now that plugins are loaded, get list of all fail_on messages, and
-        # enable them
-        self.enable_fail_on_messages()
-
-        self._parse_error_mode()
-
-        # Link the base Namespace object on the current directory
-        self._directory_namespaces[Path().resolve()] = (self.config, {})
-
+    def config_from_file(self, config_file: Optional[Union[str, Path]] = None) -> bool:
+        """Initialize the configuration from a file."""
+        _config_initialization(self, [], config_file=config_file)
         return True
 
-    def _expand_files(self, modules):
-        expanded = super()._expand_files(modules)
-        filtered = {}
+    def _expand_files(self, files_or_modules: list[str]) -> Union[Iterable[Any], dict[str, Any]]:
+        expanded = super()._expand_files(files_or_modules)
+        filtered: dict[str, Any] = {}
         # PyLinter._expand_files returns dict since 2.15.7.
         if packaging_version.parse(pylint_version) > packaging_version.parse("2.15.6"):
-            for module in expanded:
+            for module, expanded_module in expanded.items():
                 if not self._files.is_excluded(Path(module)):
-                    filtered[module] = expanded[module]
+                    filtered[module] = expanded_module
             return filtered
         else:
             for module in expanded:

prospector/tools/pyright/__init__.py

@@ -1,14 +1,21 @@
 import json
-import subprocess
+import subprocess  # nosec
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Optional
 
 import pyright
 
+from prospector.finder import FileFinder
 from prospector.message import Location, Message
 from prospector.tools import ToolBase
+from prospector.tools.exceptions import BadToolConfig
+
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
 
 __all__ = ("PyrightTool",)
 
-from prospector.tools.exceptions import BadToolConfig
 
 VALID_OPTIONS = [
     "level",
@@ -21,7 +28,7 @@ VALID_OPTIONS = [
 ]
 
 
-def format_messages(json_encoded):
+def format_messages(json_encoded: str) -> list[Message]:
     json_decoded = json.loads(json_encoded)
     diagnostics = json_decoded.get("generalDiagnostics", [])
     messages = []
@@ -42,15 +49,17 @@ def format_messages(json_encoded):
 
 
 class PyrightTool(ToolBase):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.checker = pyright
         self.options = ["--outputjson"]
 
-    def configure(self, prospector_config, _):
+    def configure(  # pylint: disable=useless-return
+        self, prospector_config: "ProspectorConfig", _: Any
+    ) -> Optional[tuple[str, Optional[Iterable[Message]]]]:
         options = prospector_config.tool_options("pyright")
 
-        for option_key in options.keys():
+        for option_key in options:
             if option_key not in VALID_OPTIONS:
                 url = "https://github.com/PyCQA/prospector/blob/master/prospector/tools/pyright/__init__.py"
                 raise BadToolConfig(
@@ -80,7 +89,9 @@ class PyrightTool(ToolBase):
         if venv_path:
             self.options.extend(["--venv-path", venv_path])
 
-    def run(self, found_files):
+        return None
+
+    def run(self, found_files: FileFinder) -> list[Message]:
         paths = [str(path) for path in found_files.python_modules]
         paths.extend(self.options)
         result = self.checker.run(*paths, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

prospector/tools/pyroma/__init__.py

@@ -1,5 +1,6 @@
 import logging
-from typing import TYPE_CHECKING, List
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Optional
 
 from prospector.finder import FileFinder
 from prospector.message import Location, Message
@@ -48,7 +49,7 @@ PYROMA_ALL_CODES = {
 PYROMA_CODES = {}
 
 
-def _copy_codes():
+def _copy_codes() -> None:
     for name, code in PYROMA_ALL_CODES.items():
         if hasattr(ratings, name):
             PYROMA_CODES[getattr(ratings, name)] = code
@@ -60,14 +61,17 @@ PYROMA_TEST_CLASSES = [t.__class__ for t in ratings.ALL_TESTS]
 
 
 class PyromaTool(ToolBase):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self.ignore_codes = ()
+        self.ignore_codes: list[str] = []
 
-    def configure(self, prospector_config: "ProspectorConfig", found_files: FileFinder):
+    def configure(  # pylint: disable=useless-return
+        self, prospector_config: "ProspectorConfig", found_files: FileFinder
+    ) -> Optional[tuple[str, Optional[Iterable[Message]]]]:
         self.ignore_codes = prospector_config.get_disabled_messages("pyroma")
+        return None
 
-    def run(self, found_files: FileFinder) -> List[Message]:
+    def run(self, found_files: FileFinder) -> list[Message]:
         messages = []
         for directory in found_files.directories:
             # just list directories which are not ignored, but find any `setup.py` ourselves

prospector/tools/ruff/__init__.py

@@ -0,0 +1,75 @@
+import json
+import subprocess  # nosec
+from typing import TYPE_CHECKING, Any
+
+from ruff.__main__ import find_ruff_bin
+
+from prospector.finder import FileFinder
+from prospector.message import Location, Message
+from prospector.tools.base import ToolBase
+
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
+
+class RuffTool(ToolBase):
+    def configure(self, prospector_config: "ProspectorConfig", _: Any) -> None:
+        self.ruff_bin = find_ruff_bin()
+        self.ruff_args = ["check", "--output-format=json"]
+
+        enabled = prospector_config.get_enabled_messages("ruff")
+        if enabled:
+            enabled_arg_value = ",".join(enabled)
+            self.ruff_args.append(f"--select={enabled_arg_value}")
+        disabled = prospector_config.get_disabled_messages("ruff")
+        if disabled:
+            disabled_arg_value = ",".join(disabled)
+            self.ruff_args.append(f"--ignore={disabled_arg_value}")
+
+        options = prospector_config.tool_options("ruff")
+        for key, value in options.items():
+            if value is True:
+                self.ruff_args.append(f"--{key}")
+            elif value is False:
+                pass
+            elif isinstance(value, list):
+                arg_value = ",".join(value)
+                self.ruff_args.append(f"--{key}={arg_value}")
+            # dict is like array but with a dict with true/false value to be able to merge profiles
+            elif isinstance(value, dict):
+                arg_value = ",".join(k for k, v in value.items() if v)
+                self.ruff_args.append(f"--{key}={arg_value}")
+            else:
+                self.ruff_args.append(f"--{key}={value}")
+
+    def run(self, found_files: FileFinder) -> list[Message]:
+        print([self.ruff_bin, *self.ruff_args])
+        messages = []
+        completed_process = subprocess.run(  # noqa: S603
+            [self.ruff_bin, *self.ruff_args, *found_files.python_modules], capture_output=True
+        )
+        for message in json.loads(completed_process.stdout):
+            sub_message = {}
+            if message.get("url"):
+                sub_message["See"] = message["url"]
+            if message.get("fix") and message["fix"].get("applicability"):
+                sub_message["Fix applicability"] = message["fix"]["applicability"]
+            message_str = message.get("message", "")
+            if sub_message:
+                message_str += f" [{', '.join(f'{k}: {v}' for k, v in sub_message.items())}]"
+
+            messages.append(
+                Message(
+                    "ruff",
+                    message.get("code") or "unknown",
+                    Location(
+                        message.get("filename") or "unknown",
+                        None,
+                        None,
+                        line=message.get("location", {}).get("row"),
+                        character=message.get("location", {}).get("column"),
+                    ),
+                    message_str,
+                )
+            )
+        return messages

prospector/tools/utils.py

@@ -1,47 +1,55 @@
 import sys
+from io import TextIOWrapper
+from typing import Optional
 
 
-class CaptureStream:
-    def __init__(self):
+class CaptureStream(TextIOWrapper):
+    def __init__(self) -> None:
         self.contents = ""
 
-    def write(self, text):
+    def write(self, text: str, /) -> int:
         self.contents += text
+        return len(text)
 
-    def close(self):
+    def close(self) -> None:
         pass
 
-    def flush(self):
+    def flush(self) -> None:
         pass
 
 
 class CaptureOutput:
-    def __init__(self, hide):
+    _prev_streams = None
+    stdout: Optional[TextIOWrapper] = None
+    stderr: Optional[TextIOWrapper] = None
+
+    def __init__(self, hide: bool) -> None:
         self.hide = hide
-        self._prev_streams = None
-        self.stdout, self.stderr = None, None
 
-    def __enter__(self):
+    def __enter__(self) -> "CaptureOutput":
         if self.hide:
-            self._prev_streams = [
+            self._prev_streams = (
                 sys.stdout,
                 sys.stderr,
                 sys.__stdout__,
                 sys.__stderr__,
-            ]
+            )
             self.stdout = CaptureStream()
             self.stderr = CaptureStream()
-            sys.stdout, sys.__stdout__ = self.stdout, self.stdout
-            sys.stderr, sys.__stderr__ = self.stderr, self.stderr
+            sys.stdout, sys.__stdout__ = self.stdout, self.stdout  # type: ignore[misc]
+            sys.stderr, sys.__stderr__ = self.stderr, self.stderr  # type: ignore[misc]
         return self
 
-    def get_hidden_stdout(self):
+    def get_hidden_stdout(self) -> str:
+        assert isinstance(self.stdout, CaptureStream)
         return self.stdout.contents
 
-    def get_hidden_stderr(self):
+    def get_hidden_stderr(self) -> str:
+        assert isinstance(self.stderr, CaptureStream)
         return self.stderr.contents
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type: type, exc_val: Exception, exc_tb: type) -> None:
         if self.hide:
-            sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__ = self._prev_streams
+            assert self._prev_streams is not None
+            sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__ = self._prev_streams  # type: ignore[misc]
             del self._prev_streams

prospector/tools/vulture/__init__.py

@@ -1,19 +1,27 @@
+from collections.abc import Iterable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional
+
 from vulture import Vulture
 
 from prospector.encoding import CouldNotHandleEncoding, read_py_file
+from prospector.finder import FileFinder
 from prospector.message import Location, Message, make_tool_error_message
 from prospector.tools.base import ToolBase
 
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
 
 class ProspectorVulture(Vulture):
-    def __init__(self, found_files):
+    def __init__(self, found_files: FileFinder) -> None:
         Vulture.__init__(self, verbose=False)
         self._files = found_files
-        self._internal_messages = []
-        self.file = None
-        self.filename = None
+        self._internal_messages: list[Message] = []
+        self.file: Optional[Path] = None
+        self.filename: Optional[Path] = None
 
-    def scavenge(self, _=None, __=None):
+    def scavenge(self, _: Any = None, __: Any = None) -> None:
         # The argument is a list of paths, but we don't care
         # about that as we use the found_files object. The
         # argument is here to explicitly acknowledge that we
@@ -27,7 +35,9 @@ class ProspectorVulture(Vulture):
                         module,
                         "vulture",
                         "V000",
-                        message=f"Could not handle the encoding of this file: {err.encoding}",
+                        message=(
+                            f"Could not handle the encoding of this file: {err.encoding}"  # type: ignore[attr-defined]
+                        ),
                     )
                 )
                 continue
@@ -38,7 +48,7 @@ class ProspectorVulture(Vulture):
             except TypeError:
                 self.scan(module_string)
 
-    def get_messages(self):
+    def get_messages(self) -> list[Message]:
         all_items = (
             ("unused-function", "Unused function %s", self.unused_funcs),
             ("unused-property", "Unused property %s", self.unused_props),
@@ -53,10 +63,7 @@ class ProspectorVulture(Vulture):
                     filename = item.file
                 except AttributeError:
                     filename = item.filename
-                if hasattr(item, "lineno"):
-                    lineno = item.lineno  # for older versions of vulture
-                else:
-                    lineno = item.first_lineno
+                lineno = item.lineno if hasattr(item, "lineno") else item.first_lineno
                 loc = Location(filename, None, None, lineno, -1)
                 message_text = template % item
                 message = Message("vulture", code, loc, message_text)
@@ -66,15 +73,18 @@ class ProspectorVulture(Vulture):
 
 
 class VultureTool(ToolBase):
-    def __init__(self):
+    def __init__(self) -> None:
         ToolBase.__init__(self)
         self._vulture = None
-        self.ignore_codes = ()
+        self.ignore_codes: list[str] = []
 
-    def configure(self, prospector_config, found_files):
+    def configure(  # pylint: disable=useless-return
+        self, prospector_config: "ProspectorConfig", found_files: FileFinder
+    ) -> Optional[tuple[Optional[str], Optional[Iterable[Message]]]]:
         self.ignore_codes = prospector_config.get_disabled_messages("vulture")
+        return None
 
-    def run(self, found_files):
+    def run(self, found_files: FileFinder) -> list[Message]:
         vulture = ProspectorVulture(found_files)
         vulture.scavenge()
         return [message for message in vulture.get_messages() if message.code not in self.ignore_codes]