prospector 1.10.3__py3-none-any.whl → 1.13.2__py3-none-any.whl

prospector/profiles/exceptions.py

@@ -1,28 +1,31 @@
+from pathlib import Path
+
+
 class ProfileNotFound(Exception):
-    def __init__(self, name, profile_path):
+    def __init__(self, name: str, profile_path: list[Path]) -> None:
         super().__init__()
         self.name = name
         self.profile_path = profile_path
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Could not find profile {}; searched in {}".format(
             self.name,
-            ":".join(self.profile_path),
+            ":".join(map(str, self.profile_path)),
         )
 
 
 class CannotParseProfile(Exception):
-    def __init__(self, filepath, parse_error):
+    def __init__(self, filepath: str, parse_error: Exception) -> None:
         super().__init__()
         self.filepath = filepath
         self.parse_error = parse_error
 
-    def get_parse_message(self):
-        return "{}\n  on line {} : char {}".format(
-            self.parse_error.problem,
-            self.parse_error.problem_mark.line,
-            self.parse_error.problem_mark.column,
+    def get_parse_message(self) -> str:
+        return (
+            f"{self.parse_error.problem}\n"  # type: ignore[attr-defined]
+            f"  on line {self.parse_error.problem_mark.line}: "  # type: ignore[attr-defined]
+            f"char {self.parse_error.problem_mark.column}"  # type: ignore[attr-defined]
         )
 
-    def __repr__(self):
-        return "Could not parse profile found at %s - it is not valid YAML" % self.filepath
+    def __repr__(self) -> str:
+        return f"Could not parse profile found at {self.filepath} - it is not valid YAML"

prospector/profiles/profile.py

@@ -3,7 +3,7 @@ import json
 import os
 import pkgutil
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import yaml
 
@@ -14,7 +14,7 @@ BUILTIN_PROFILE_PATH = (Path(__file__).parent / "profiles").absolute()
 
 
 class ProspectorProfile:
-    def __init__(self, name: str, profile_dict: Dict[str, Any], inherit_order: List[str]):
+    def __init__(self, name: str, profile_dict: dict[str, Any], inherit_order: list[str]) -> None:
         self.name = name
         self.inherit_order = inherit_order
 
@@ -43,7 +43,7 @@ class ProspectorProfile:
             tool_conf = profile_dict.get(tool, {})
 
             # set the defaults for everything
-            conf: Dict[str, Any] = {"disable": [], "enable": [], "run": None, "options": {}}
+            conf: dict[str, Any] = {"disable": [], "enable": [], "run": None, "options": {}}
             # use the "old" tool name
             conf.update(tool_conf)
 
@@ -52,23 +52,28 @@ class ProspectorProfile:
 
             setattr(self, tool, conf)
 
-    def get_disabled_messages(self, tool_name):
+    def get_disabled_messages(self, tool_name: str) -> list[str]:
         disable = getattr(self, tool_name)["disable"]
         enable = getattr(self, tool_name)["enable"]
         return list(set(disable) - set(enable))
 
-    def is_tool_enabled(self, name):
-        enabled = getattr(self, name).get("run")
+    def get_enabled_messages(self, tool_name: str) -> list[str]:
+        disable = getattr(self, tool_name)["disable"]
+        enable = getattr(self, tool_name)["enable"]
+        return list(set(enable) - set(disable))
+
+    def is_tool_enabled(self, name: str) -> bool:
+        enabled: Optional[bool] = getattr(self, name).get("run")
         if enabled is not None:
             return enabled
         # this is not explicitly enabled or disabled, so use the default
         return name in DEFAULT_TOOLS
 
-    def list_profiles(self):
+    def list_profiles(self) -> list[str]:
         # this profile is itself included
         return [str(profile) for profile in self.inherit_order]
 
-    def as_dict(self):
+    def as_dict(self) -> dict[str, Any]:
         out = {
             "ignore-paths": self.ignore_paths,
             "ignore-patterns": self.ignore_patterns,
@@ -87,19 +92,19 @@ class ProspectorProfile:
             out[tool] = getattr(self, tool)
         return out
 
-    def as_json(self):
+    def as_json(self) -> str:
         return json.dumps(self.as_dict())
 
-    def as_yaml(self):
+    def as_yaml(self) -> str:
         return yaml.safe_dump(self.as_dict())
 
     @staticmethod
     def load(
         name_or_path: Union[str, Path],
-        profile_path: List[Path],
+        profile_path: list[Path],
         allow_shorthand: bool = True,
-        forced_inherits: Optional[List[str]] = None,
-    ):
+        forced_inherits: Optional[list[str]] = None,
+    ) -> "ProspectorProfile":
         # First simply load all of the profiles and those that it explicitly inherits from
         data, inherits = _load_and_merge(
             name_or_path,
@@ -110,18 +115,18 @@ class ProspectorProfile:
         return ProspectorProfile(str(name_or_path), data, inherits)
 
 
-def _is_valid_extension(filename):
+def _is_valid_extension(filename: Union[str, Path]) -> bool:
     ext = os.path.splitext(filename)[1]
     return ext in (".yml", ".yaml")
 
 
-def _load_content_package(name):
+def _load_content_package(name: str) -> Optional[dict[str, Any]]:
     name_split = name.split(":", 1)
     module_name = f"prospector_profile_{name_split[0]}"
     file_names = (
         ["prospector.yaml", "prospector.yml"]
         if len(name_split) == 1
-        else [f"{name_split[1]}.yaml", f"{name_split[1]}.yaml"]
+        else [f"{name_split[1]}.yaml", f"{name_split[1]}.yml"]
     )
 
     data = None
@@ -138,10 +143,11 @@ def _load_content_package(name):
     try:
         return yaml.safe_load(data) or {}
     except yaml.parser.ParserError as parse_error:
+        assert used_name is not None
         raise CannotParseProfile(used_name, parse_error) from parse_error
 
 
-def _load_content(name_or_path, profile_path):
+def _load_content(name_or_path: Union[str, Path], profile_path: list[Path]) -> dict[str, Any]:
     filename = None
     optional = False
 
@@ -165,14 +171,14 @@ def _load_content(name_or_path, profile_path):
                     break
 
     if filename is None:
-        result = _load_content_package(name_or_path)
+        result = _load_content_package(str(name_or_path))
         if result is not None:
             return result
 
         if optional:
             return {}
 
-        raise ProfileNotFound(name_or_path, profile_path)
+        raise ProfileNotFound(str(name_or_path), profile_path)
 
     with codecs.open(filename) as fct:
         try:
@@ -181,37 +187,34 @@ def _load_content(name_or_path, profile_path):
             raise CannotParseProfile(filename, parse_error) from parse_error
 
 
-def _ensure_list(value):
+def _ensure_list(value: Any) -> list[Any]:
     if isinstance(value, list):
         return value
     return [value]
 
 
-def _simple_merge_dict(priority, base):
-    out = dict(base.items())
-    out.update(dict(priority.items()))
+def _simple_merge_dict(priority: dict[str, Any], base: dict[str, Any]) -> dict[str, Any]:
+    out = {**base, **priority}
+    keys = set(priority.keys()) | set(base.keys())
+    for key in keys:
+        if isinstance(base.get(key), dict) and isinstance(priority.get(key), dict):
+            out[key] = _simple_merge_dict(priority[key], base[key])
     return out
 
 
-def _merge_tool_config(priority, base):
-    out = dict(base.items())
+def _merge_tool_config(priority: dict[str, Any], base: dict[str, Any]) -> dict[str, Any]:
+    out = {**base, **priority}
 
     # add options that are missing, but keep existing options from the priority dictionary
     # TODO: write a unit test for this :-|
     out["options"] = _simple_merge_dict(priority.get("options", {}), base.get("options", {}))
 
-    # copy in some basic pieces
-    for key in ("run", "load-plugins"):
-        value = priority.get(key, base.get(key))
-        if value is not None:
-            out[key] = value
-
     # anything enabled in the 'priority' dict is removed
     # from 'disabled' in the base dict and vice versa
-    base_disabled = base.get("disable") or []
-    base_enabled = base.get("enable") or []
-    pri_disabled = priority.get("disable") or []
-    pri_enabled = priority.get("enable") or []
+    base_disabled: list[Any] = base.get("disable") or []
+    base_enabled: list[Any] = base.get("enable") or []
+    pri_disabled: list[Any] = priority.get("disable") or []
+    pri_enabled: list[Any] = priority.get("enable") or []
 
     out["disable"] = list(set(pri_disabled) | (set(base_disabled) - set(pri_enabled)))
     out["enable"] = list(set(pri_enabled) | (set(base_enabled) - set(pri_disabled)))
@@ -219,7 +222,7 @@ def _merge_tool_config(priority, base):
     return out
 
 
-def _merge_profile_dict(priority: dict, base: dict) -> dict:
+def _merge_profile_dict(priority: dict[str, Any], base: dict[str, Any]) -> dict[str, Any]:
     # copy the base dict into our output
     out = dict(base.items())
 
@@ -254,7 +257,7 @@ def _merge_profile_dict(priority: dict, base: dict) -> dict:
     return out
 
 
-def _determine_strictness(profile_dict, inherits):
+def _determine_strictness(profile_dict: dict[str, Any], inherits: list[str]) -> tuple[Optional[str], bool]:
     for profile in inherits:
         if profile.startswith("strictness_"):
             return None, False
@@ -262,10 +265,10 @@ def _determine_strictness(profile_dict, inherits):
     strictness = profile_dict.get("strictness")
     if strictness is None:
         return None, False
-    return ("strictness_%s" % strictness), True
+    return (f"strictness_{strictness}"), True
 
 
-def _determine_pep8(profile_dict):
+def _determine_pep8(profile_dict: dict[str, Any]) -> tuple[Optional[str], bool]:
     pep8 = profile_dict.get("pep8")
     if pep8 == "full":
         return "full_pep8", True
@@ -276,28 +279,30 @@ def _determine_pep8(profile_dict):
     return None, False
 
 
-def _determine_doc_warnings(profile_dict):
+def _determine_doc_warnings(profile_dict: dict[str, Any]) -> tuple[Optional[str], bool]:
     doc_warnings = profile_dict.get("doc-warnings")
     if doc_warnings is None:
         return None, False
     return ("doc_warnings" if doc_warnings else "no_doc_warnings"), True
 
 
-def _determine_test_warnings(profile_dict):
+def _determine_test_warnings(profile_dict: dict[str, Any]) -> tuple[Optional[str], bool]:
     test_warnings = profile_dict.get("test-warnings")
     if test_warnings is None:
         return None, False
     return (None if test_warnings else "no_test_warnings"), True
 
 
-def _determine_member_warnings(profile_dict):
+def _determine_member_warnings(profile_dict: dict[str, Any]) -> tuple[Optional[str], bool]:
     member_warnings = profile_dict.get("member-warnings")
     if member_warnings is None:
         return None, False
     return ("member_warnings" if member_warnings else "no_member_warnings"), True
 
 
-def _determine_implicit_inherits(profile_dict, already_inherits, shorthands_found):
+def _determine_implicit_inherits(
+    profile_dict: dict[str, Any], already_inherits: list[str], shorthands_found: set[str]
+) -> tuple[list[str], set[str]]:
     # Note: the ordering is very important here - the earlier items
     # in the list have precedence over the later items. The point of
     # the doc/test/pep8 profiles is usually to restore items which were
@@ -324,7 +329,13 @@ def _determine_implicit_inherits(profile_dict, already_inherits, shorthands_foun
     return inherits, shorthands_found
 
 
-def _append_profiles(name, profile_path, data, inherit_list, allow_shorthand=False):
+def _append_profiles(
+    name: str,
+    profile_path: list[Path],
+    data: dict[Union[str, Path], Any],
+    inherit_list: list[str],
+    allow_shorthand: bool = False,
+) -> tuple[dict[Union[str, Path], Any], list[str]]:
     new_data, new_il, _ = _load_profile(name, profile_path, allow_shorthand=allow_shorthand)
     data.update(new_data)
     inherit_list += new_il
@@ -333,10 +344,10 @@ def _append_profiles(name, profile_path, data, inherit_list, allow_shorthand=Fal
 
 def _load_and_merge(
     name_or_path: Union[str, Path],
-    profile_path: List[Path],
+    profile_path: list[Path],
     allow_shorthand: bool = True,
-    forced_inherits: List[str] = None,
-) -> Tuple[Dict[str, Any], List[str]]:
+    forced_inherits: Optional[list[str]] = None,
+) -> tuple[dict[str, Any], list[str]]:
     # First simply load all of the profiles and those that it explicitly inherits from
     data, inherit_list, shorthands_found = _load_profile(
         str(name_or_path),
@@ -367,7 +378,7 @@ def _load_and_merge(
     # top of the inheritance tree to the bottom). This means that the lower down
     # values overwrite those from above, meaning that the initially provided profile
     # has precedence.
-    merged: dict = {}
+    merged: dict[str, Any] = {}
     for name in inherit_list[::-1]:
         priority = data[name]
         merged = _merge_profile_dict(priority, merged)
@@ -375,7 +386,7 @@ def _load_and_merge(
     return merged, inherit_list
 
 
-def _transform_legacy(profile_dict):
+def _transform_legacy(profile_dict: dict[str, Any]) -> dict[str, Any]:
     """
     After pep8 was renamed to pycodestyle, this pre-filter just moves profile
     config blocks using the old name to use the new name, merging if both are
@@ -419,19 +430,19 @@ def _transform_legacy(profile_dict):
 
 
 def _load_profile(
-    name_or_path,
-    profile_path,
-    shorthands_found=None,
-    already_loaded=None,
-    allow_shorthand=True,
-    forced_inherits=None,
-):
+    name_or_path: Union[str, Path],
+    profile_path: list[Path],
+    shorthands_found: Optional[set[str]] = None,
+    already_loaded: Optional[list[Union[str, Path]]] = None,
+    allow_shorthand: bool = True,
+    forced_inherits: Optional[list[str]] = None,
+) -> tuple[dict[Union[str, Path], Any], list[str], set[str]]:
     # recursively get the contents of the basic profile and those it inherits from
     base_contents = _load_content(name_or_path, profile_path)
 
     base_contents = _transform_legacy(base_contents)
 
-    inherit_order = [name_or_path]
+    inherit_order = [str(name_or_path)]
     shorthands_found = shorthands_found or set()
 
     already_loaded = already_loaded or []
@@ -448,7 +459,7 @@ def _load_profile(
         inherits += extra_inherits
         shorthands_found |= extra_shorthands
 
-    contents_dict = {name_or_path: base_contents}
+    contents_dict: dict[Union[str, Path], Any] = {name_or_path: base_contents}
 
     for inherit_profile in inherits:
         if inherit_profile in already_loaded:
@@ -470,4 +481,4 @@ def _load_profile(
     # note: a new list is returned here rather than simply using inherit_order to give astroid a
     # clue about the type of the returned object, as otherwise it can recurse infinitely and crash,
     # this meaning that prospector does not run on prospector cleanly!
-    return contents_dict, list(inherit_order), shorthands_found
+    return contents_dict, inherit_order, shorthands_found

prospector/run.py

@@ -1,10 +1,11 @@
+import argparse
 import codecs
 import os.path
 import sys
 import warnings
 from datetime import datetime
 from pathlib import Path
-from typing import TextIO
+from typing import Any, Optional, TextIO
 
 from prospector import blender, postfilter, tools
 from prospector.compat import is_relative_to
@@ -19,12 +20,12 @@ from prospector.tools.utils import CaptureOutput
 
 
 class Prospector:
-    def __init__(self, config: ProspectorConfig):
+    def __init__(self, config: ProspectorConfig) -> None:
         self.config = config
-        self.summary = None
+        self.summary: Optional[dict[str, Any]] = None
         self.messages = config.messages
 
-    def process_messages(self, found_files, messages):
+    def process_messages(self, found_files: FileFinder, messages: list[Message]) -> list[Message]:
         if self.config.blending:
             messages = blender.blend(messages)
 
@@ -38,10 +39,10 @@ class Prospector:
 
         return postfilter.filter_messages(found_files.python_modules, messages)
 
-    def execute(self):
+    def execute(self) -> None:
         deprecated_names = self.config.replace_deprecated_tool_names()
 
-        summary = {
+        summary: dict[str, Any] = {
             "started": datetime.now(),
         }
         summary.update(self.config.get_summary_information())
@@ -67,7 +68,7 @@ class Prospector:
                 message=msg,
             )
             messages.append(message)
-            warnings.warn(msg, category=DeprecationWarning)
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=0)
 
         # Run the tools
         for tool in self.config.get_tools(found_files):
@@ -121,28 +122,29 @@ class Prospector:
         summary["completed"] = datetime.now()
 
         delta = summary["completed"] - summary["started"]
-        summary["time_taken"] = "%0.2f" % delta.total_seconds()
+        summary["time_taken"] = f"{delta.total_seconds():0.2f}"
 
         external_config = []
-        for tool, configured_by in self.config.configured_by.items():
+        for tool_name, configured_by in self.config.configured_by.items():
             if configured_by is not None:
-                external_config.append((tool, configured_by))
+                external_config.append((tool_name, configured_by))
         if len(external_config) > 0:
-            summary["external_config"] = ", ".join(["%s: %s" % info for info in external_config])
+            summary["external_config"] = ", ".join(["{}: {}".format(*info) for info in external_config])
 
         self.summary = summary
         self.messages = self.messages + messages
 
-    def get_summary(self):
+    def get_summary(self) -> Optional[dict[str, Any]]:
         return self.summary
 
-    def get_messages(self):
+    def get_messages(self) -> list[Message]:
         return self.messages
 
-    def print_messages(self):
+    def print_messages(self) -> None:
         output_reports = self.config.get_output_report()
 
         for report in output_reports:
+            assert self.summary is not None
             output_format, output_files = report
             self.summary["formatter"] = output_format
 
@@ -161,7 +163,7 @@ class Prospector:
                 with codecs.open(output_file, "w+") as target:
                     self.write_to(formatter, target)
 
-    def write_to(self, formatter: Formatter, target: TextIO):
+    def write_to(self, formatter: Formatter, target: TextIO) -> None:
         # Produce the output
         target.write(
             formatter.render(
@@ -173,7 +175,7 @@ class Prospector:
         target.write("\n")
 
 
-def get_parser():
+def get_parser() -> argparse.ArgumentParser:
     """
     This is a helper method to return an argparse parser, to
     be used with the Sphinx argparse plugin for documentation.
@@ -183,13 +185,13 @@ def get_parser():
     return source.build_parser(manager.settings, None)
 
 
-def main():
+def main() -> None:
     # Get our configuration
     config = ProspectorConfig()
 
     paths = config.paths
     if len(paths) > 1 and not all(os.path.isfile(path) for path in paths):
-        sys.stderr.write("\nIn multi-path mode, all inputs must be files, " "not directories.\n\n")
+        sys.stderr.write("\nIn multi-path mode, all inputs must be files, not directories.\n\n")
         get_parser().print_usage()
         sys.exit(2)
 

prospector/suppression.py

@@ -19,11 +19,12 @@ in the file:
 This module's job is to attempt to collect all of these methods into
 a single coherent list of error suppression locations.
 """
+
 import re
 import warnings
 from collections import defaultdict
 from pathlib import Path
-from typing import List
+from typing import Optional
 
 from prospector import encoding
 from prospector.exceptions import FatalProspectorException
@@ -34,7 +35,7 @@ _PEP8_IGNORE_LINE = re.compile(r"#\s+noqa", re.IGNORECASE)
 _PYLINT_SUPPRESSED_MESSAGE = re.compile(r"^Suppressed \'([a-z0-9-]+)\' \(from line \d+\)$")
 
 
-def get_noqa_suppressions(file_contents):
+def get_noqa_suppressions(file_contents: list[str]) -> tuple[bool, set[int]]:
     """
     Finds all pep8/flake8 suppression messages
 
@@ -63,9 +64,11 @@ _PYLINT_EQUIVALENTS = {
 }
 
 
-def _parse_pylint_informational(messages: List[Message]):
-    ignore_files = set()
-    ignore_messages: dict = defaultdict(lambda: defaultdict(list))
+def _parse_pylint_informational(
+    messages: list[Message],
+) -> tuple[set[Optional[Path]], dict[Optional[Path], dict[int, list[str]]]]:
+    ignore_files: set[Optional[Path]] = set()
+    ignore_messages: dict[Optional[Path], dict[int, list[str]]] = defaultdict(lambda: defaultdict(list))
 
     for message in messages:
         if message.source == "pylint":
@@ -77,21 +80,24 @@ def _parse_pylint_informational(messages: List[Message]):
                     raise FatalProspectorException(f"Could not parsed suppressed message from {message.message}")
                 suppressed_code = match.group(1)
                 line_dict = ignore_messages[message.location.path]
+                assert message.location.line is not None
                 line_dict[message.location.line].append(suppressed_code)
             elif message.code == "file-ignored":
                 ignore_files.add(message.location.path)
     return ignore_files, ignore_messages
 
 
-def get_suppressions(filepaths: List[Path], messages):
+def get_suppressions(
+    filepaths: list[Path], messages: list[Message]
+) -> tuple[set[Optional[Path]], dict[Path, set[int]], dict[Optional[Path], dict[int, set[tuple[str, str]]]]]:
     """
     Given every message which was emitted by the tools, and the
     list of files to inspect, create a list of files to ignore,
     and a map of filepath -> line-number -> codes to ignore
     """
-    paths_to_ignore = set()
-    lines_to_ignore: dict = defaultdict(set)
-    messages_to_ignore: dict = defaultdict(lambda: defaultdict(set))
+    paths_to_ignore: set[Optional[Path]] = set()
+    lines_to_ignore: dict[Path, set[int]] = defaultdict(set)
+    messages_to_ignore: dict[Optional[Path], dict[int, set[tuple[str, str]]]] = defaultdict(lambda: defaultdict(set))
 
     # first deal with 'noqa' style messages
     for filepath in filepaths:
@@ -99,7 +105,7 @@ def get_suppressions(filepaths: List[Path], messages):
             file_contents = encoding.read_py_file(filepath).split("\n")
         except encoding.CouldNotHandleEncoding as err:
             # TODO: this output will break output formats such as JSON
-            warnings.warn(f"{err.path}: {err.__cause__}", ImportWarning)
+            warnings.warn(f"{err.path}: {err.__cause__}", ImportWarning, stacklevel=2)
             continue
 
         ignore_file, ignore_lines = get_noqa_suppressions(file_contents)
@@ -110,12 +116,12 @@ def get_suppressions(filepaths: List[Path], messages):
     # now figure out which messages were suppressed by pylint
     pylint_ignore_files, pylint_ignore_messages = _parse_pylint_informational(messages)
     paths_to_ignore |= pylint_ignore_files
-    for filepath, line in pylint_ignore_messages.items():
+    for pylint_filepath, line in pylint_ignore_messages.items():
         for line_number, codes in line.items():
             for code in codes:
-                messages_to_ignore[filepath][line_number].add(("pylint", code))
+                messages_to_ignore[pylint_filepath][line_number].add(("pylint", code))
                 if code in _PYLINT_EQUIVALENTS:
                     for equivalent in _PYLINT_EQUIVALENTS[code]:
-                        messages_to_ignore[filepath][line_number].add(equivalent)
+                        messages_to_ignore[pylint_filepath][line_number].add(equivalent)
 
     return paths_to_ignore, lines_to_ignore, messages_to_ignore

prospector/tools/__init__.py

@@ -1,16 +1,22 @@
-import importlib
+from typing import TYPE_CHECKING, Any, Optional
 
 from prospector.exceptions import FatalProspectorException
+from prospector.finder import FileFinder
+from prospector.message import Message
 from prospector.tools.base import ToolBase
 from prospector.tools.dodgy import DodgyTool
 from prospector.tools.mccabe import McCabeTool
+from prospector.tools.profile_validator import ProfileValidationTool  # pylint: disable=cyclic-import
 from prospector.tools.pycodestyle import PycodestyleTool
 from prospector.tools.pydocstyle import PydocstyleTool
 from prospector.tools.pyflakes import PyFlakesTool
 from prospector.tools.pylint import PylintTool
 
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
 
-def _tool_not_available(name, install_option_name):
+
+def _tool_not_available(name: str, install_option_name: str) -> type[ToolBase]:
     class NotAvailableTool(ToolBase):
         """
         Dummy tool class to return when a particular dependency is not found (such as mypy, or bandit)
@@ -18,10 +24,10 @@ def _tool_not_available(name, install_option_name):
         if the user tries to run prospector and specifies using the tool at which point an error is raised.
         """
 
-        def configure(self, prospector_config, found_files):
+        def configure(self, prospector_config: "ProspectorConfig", found_files: FileFinder) -> None:
             pass
 
-        def run(self, _):
+        def run(self, _: Any) -> list[Message]:
             raise FatalProspectorException(
                 f"\nCannot run tool {name} as support was not installed.\n"
                 f"Please install by running 'pip install prospector[{install_option_name}]'\n\n"
@@ -30,7 +36,12 @@ def _tool_not_available(name, install_option_name):
     return NotAvailableTool
 
 
-def _optional_tool(name, package_name=None, tool_class_name=None, install_option_name=None):
+def _optional_tool(
+    name: str,
+    package_name: Optional[str] = None,
+    tool_class_name: Optional[str] = None,
+    install_option_name: Optional[str] = None,
+) -> type[ToolBase]:
     package_name = "prospector.tools.%s" % (package_name or name)
     tool_class_name = tool_class_name or f"{name.title()}Tool"
     install_option_name = install_option_name or f"with_{name}"
@@ -45,25 +56,20 @@ def _optional_tool(name, package_name=None, tool_class_name=None, install_option
     return tool_class
 
 
-def _profile_validator_tool(*args, **kwargs):
-    # bit of a hack to avoid a cyclic import...
-    mdl = importlib.import_module("prospector.tools.profile_validator")
-    return mdl.ProfileValidationTool(*args, **kwargs)
-
-
-TOOLS = {
+TOOLS: dict[str, type[ToolBase]] = {
     "dodgy": DodgyTool,
     "mccabe": McCabeTool,
     "pyflakes": PyFlakesTool,
     "pycodestyle": PycodestyleTool,
     "pylint": PylintTool,
     "pydocstyle": PydocstyleTool,
-    "profile-validator": _profile_validator_tool,
+    "profile-validator": ProfileValidationTool,
     "vulture": _optional_tool("vulture"),
     "pyroma": _optional_tool("pyroma"),
     "pyright": _optional_tool("pyright"),
     "mypy": _optional_tool("mypy"),
     "bandit": _optional_tool("bandit"),
+    "ruff": _optional_tool("ruff"),
 }