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

prospector/autodetect.py

@@ -2,6 +2,7 @@ import os
 import re
 import warnings
 from pathlib import Path
+from typing import Union
 
 from requirements_detector import find_requirements
 from requirements_detector.detect import RequirementsNotFound
@@ -19,7 +20,7 @@ _IMPORT_REGEX = re.compile(r"^\s*import ([\._a-zA-Z0-9]+)$")
 _IMPORT_MULTIPLE_REGEX = re.compile(r"^\s*import ([\._a-zA-Z0-9]+(, ){1})+")
 
 
-def find_from_imports(file_contents):
+def find_from_imports(file_contents: str) -> set[str]:
     names = set()
     for line in file_contents.split("\n"):
         match = _IMPORT_MULTIPLE_REGEX.match(line)
@@ -42,7 +43,7 @@ def find_from_imports(file_contents):
     return names
 
 
-def find_from_path(path: Path):
+def find_from_path(path: Path) -> set[str]:
     names = set()
 
     try:
@@ -57,7 +58,7 @@ def find_from_path(path: Path):
                     names |= find_from_imports(contents)
                 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=0)
 
             if len(names) == len(POSSIBLE_LIBRARIES):
                 # don't continue on recursing, there's no point!
@@ -68,22 +69,22 @@ def find_from_path(path: Path):
     return names
 
 
-def find_from_requirements(path):
+def find_from_requirements(path: Union[str, Path]) -> set[str]:
     reqs = find_requirements(path)
-    names = []
+    names: set[str] = set()
     for requirement in reqs:
         if requirement.name is not None and requirement.name.lower() in POSSIBLE_LIBRARIES:
-            names.append(requirement.name.lower())
+            names.add(requirement.name.lower())
     return names
 
 
-def autodetect_libraries(path):
+def autodetect_libraries(path: Union[str, Path]) -> set[str]:
     if os.path.isfile(path):
         path = os.path.dirname(path)
         if path == "":
             path = "."
 
-    libraries = []
+    libraries: set[str] = set()
 
     try:
         libraries = find_from_requirements(path)
@@ -91,6 +92,6 @@ def autodetect_libraries(path):
         pass
 
     if len(libraries) < len(POSSIBLE_LIBRARIES):
-        libraries = find_from_path(path)
+        libraries = find_from_path(Path(path))
 
     return libraries

prospector/blender.py

@@ -6,16 +6,20 @@
 # remove duplicates.
 import pkgutil
 from collections import defaultdict
+from pathlib import Path
+from typing import Optional
 
 import yaml
 
+from prospector.message import Message
+
 __all__ = (
     "blend",
     "BLEND_COMBOS",
 )
 
 
-def blend_line(messages, blend_combos=None):
+def blend_line(messages: list[Message], blend_combos: Optional[list[list[tuple[str, str]]]] = None) -> list[Message]:
     """
     Given a list of messages on the same line, blend them together so that we
     end up with one message per actual problem. Note that we can still return
@@ -23,8 +27,8 @@ def blend_line(messages, blend_combos=None):
     the line.
     """
     blend_combos = blend_combos or BLEND_COMBOS
-    blend_lists = [[] for _ in range(len(blend_combos))]
-    blended = []
+    blend_lists: list[list[Message]] = [[] for _ in range(len(blend_combos))]
+    blended: list[Message] = []
 
     # first we split messages into each of the possible blendable categories
     # so that we have a list of lists of messages which can be blended together
@@ -72,18 +76,19 @@ def blend_line(messages, blend_combos=None):
         # it will appear in two blend_lists. Therefore we mark anything not taken from the blend list
         # as "consumed" and then filter later, to avoid such cases.
         for now_used in blend_list[1:]:
-            now_used.used = True
+            now_used.used = True  # type: ignore[attr-defined]
 
     return [m for m in blended if not getattr(m, "used", False)]
 
 
-def blend(messages, blend_combos=None):
+def blend(messages: list[Message], blend_combos: Optional[list[list[tuple[str, str]]]] = None) -> list[Message]:
     blend_combos = blend_combos or BLEND_COMBOS
 
     # group messages by file and then line number
-    msgs_grouped = defaultdict(lambda: defaultdict(list))
+    msgs_grouped: dict[Path, dict[int, list[Message]]] = defaultdict(lambda: defaultdict(list))
 
     for message in messages:
+        assert message.location.line is not None
         msgs_grouped[message.location.path][message.location.line].append(
             message,
         )
@@ -97,18 +102,20 @@ def blend(messages, blend_combos=None):
     return out
 
 
-def get_default_blend_combinations():
-    combos = yaml.safe_load(pkgutil.get_data(__name__, "blender_combinations.yaml"))
+def get_default_blend_combinations() -> list[list[tuple[str, str]]]:
+    blender_combinations = pkgutil.get_data(__name__, "blender_combinations.yaml")
+    assert blender_combinations is not None
+    combos = yaml.safe_load(blender_combinations)
     combos = combos.get("combinations", [])
 
-    defaults = []
+    defaults: list[list[tuple[str, str]]] = []
     for combo in combos:
         toblend = []
         for msg in combo:
             toblend += msg.items()
-        defaults.append(tuple(toblend))
+        defaults.append(toblend)
 
-    return tuple(defaults)
+    return defaults
 
 
 BLEND_COMBOS = get_default_blend_combinations()

prospector/config/__init__.py

@@ -2,12 +2,18 @@ import os
 import re
 import sys
 from pathlib import Path
-from typing import Dict, List, Union
+from typing import Any, Callable, Optional, Union
+
+import setoptconf.config
+
+from prospector.finder import FileFinder
 
 try:  # Python >= 3.11
     import re._constants as sre_constants
 except ImportError:
-    import sre_constants
+    import sre_constants  # pylint: disable=deprecated-module
+
+import contextlib
 
 from prospector import tools
 from prospector.autodetect import autodetect_libraries
@@ -26,7 +32,7 @@ class ProspectorConfig:
     # Also the 'too many instance attributes' warning is ignored, as this
     # is a config object and its sole purpose is to hold many properties!
 
-    def __init__(self, workdir: Path = None):
+    def __init__(self, workdir: Optional[Path] = None):
         self.config, self.arguments = self._configure_prospector()
         self.paths = self._get_work_path(self.config, self.arguments)
         self.explicit_file_mode = all(p.is_file for p in self.paths)
@@ -36,17 +42,17 @@ class ProspectorConfig:
         self.libraries = self._find_used_libraries(self.config, self.profile)
         self.tools_to_run = self._determine_tool_runners(self.config, self.profile)
         self.ignores = self._determine_ignores(self.config, self.profile, self.libraries)
-        self.configured_by: Dict[str, str] = {}
-        self.messages: List[Message] = []
+        self.configured_by: dict[str, Optional[Union[str, Path]]] = {}
+        self.messages: list[Message] = []
 
-    def make_exclusion_filter(self):
+    def make_exclusion_filter(self) -> Callable[[Path], bool]:
         # Only close over the attributes required by the filter, rather
         # than the entire self, because ProspectorConfig can't be pickled
         # because of the config attribute, which would break parallel
         # pylint.
         ignores, workdir = self.ignores, self.workdir
 
-        def _filter(path: Path):
+        def _filter(path: Path) -> bool:
             for ignore in ignores:
                 # first figure out where the path is, relative to the workdir
                 # ignore-paths/patterns will usually be relative to a repository
@@ -60,26 +66,25 @@ class ProspectorConfig:
 
         return _filter
 
-    def get_tools(self, found_files):
+    def get_tools(self, found_files: FileFinder) -> list[tools.ToolBase]:
         self.configured_by = {}
         runners = []
         for tool_name in self.tools_to_run:
             tool = tools.TOOLS[tool_name]()
             config_result = tool.configure(self, found_files)
-            if config_result is None:
-                configured_by = None
-                messages = []
-            else:
-                configured_by, messages = config_result
-                if messages is None:
-                    messages = []
+            messages: list[Message] = []
+            configured_by = None
+            if config_result is not None:
+                configured_by, config_messages = config_result
+                if config_messages is not None:
+                    messages = list(config_messages)
 
             self.configured_by[tool_name] = configured_by
             self.messages += messages
             runners.append(tool)
         return runners
 
-    def replace_deprecated_tool_names(self) -> List[str]:
+    def replace_deprecated_tool_names(self) -> list[str]:
         # pep8 was renamed pycodestyle ; pep257 was renamed pydocstyle
         # for backwards compatibility, these have been deprecated but will remain until prospector v2
         deprecated_found = []
@@ -93,12 +98,13 @@ class ProspectorConfig:
         self.tools_to_run = replaced
         return deprecated_found
 
-    def get_output_report(self):
+    def get_output_report(self) -> list[tuple[str, list[str]]]:
         # Get the output formatter
+        output_report: list[tuple[str, list[str]]]
         if self.config.output_format is not None:
             output_report = self.config.output_format
         else:
-            output_report = [(self.profile.output_format, self.profile.output_target)]
+            output_report = [(self.profile.output_format, self.profile.output_target)]  # type: ignore[list-item]
 
         for index, report in enumerate(output_report):
             if not all(report):
@@ -106,13 +112,13 @@ class ProspectorConfig:
 
         return output_report
 
-    def _configure_prospector(self):
+    def _configure_prospector(self) -> tuple[setoptconf.config.Configuration, dict[str, str]]:
         # first we will configure prospector as a whole
         mgr = cfg.build_manager()
         config = mgr.retrieve(*cfg.build_default_sources())
         return config, mgr.arguments
 
-    def _get_work_path(self, config, arguments) -> List[Path]:
+    def _get_work_path(self, config: setoptconf.config.Configuration, arguments: dict[str, str]) -> list[Path]:
         # Figure out what paths we're prospecting
         if config["path"]:
             paths = [Path(self.config["path"])]
@@ -122,7 +128,9 @@ class ProspectorConfig:
             paths = [Path.cwd()]
         return [p.resolve() for p in paths]
 
-    def _get_profile(self, workdir: Path, config):
+    def _get_profile(
+        self, workdir: Path, config: setoptconf.config.Configuration
+    ) -> tuple[ProspectorProfile, Optional[str]]:
         # Use the specified profiles
         profile_provided = False
         if len(config.profiles) > 0:
@@ -168,7 +176,7 @@ class ProspectorConfig:
 
         # Use the strictness profile only if no profile has been given
         if config.strictness is not None and config.strictness:
-            cmdline_implicit.append("strictness_%s" % config.strictness)
+            cmdline_implicit.append(f"strictness_{config.strictness}")
             strictness = config.strictness
 
         # the profile path is
@@ -190,24 +198,30 @@ class ProspectorConfig:
             profile = ProspectorProfile.load(profile_name, profile_path, forced_inherits=forced_inherits)
         except CannotParseProfile as cpe:
             sys.stderr.write(
-                "Failed to run:\nCould not parse profile %s as it is not valid YAML\n%s\n"
-                % (cpe.filepath, cpe.get_parse_message())
+                "\n".join(
+                    [
+                        "Failed to run:",
+                        f"Could not parse profile {cpe.filepath} as it is not valid YAML",
+                        f"{cpe.get_parse_message()}",
+                        "",
+                    ]
+                )
             )
             sys.exit(1)
         except ProfileNotFound as nfe:
             search_path = ":".join(map(str, nfe.profile_path))
-            profile = nfe.name.split(":")[0]
+            module_name = nfe.name.split(":")[0]
             sys.stderr.write(
                 f"""Failed to run:
 Could not find profile {nfe.name}.
-Search path: {search_path}, or in module 'prospector_profile_{profile}'
+Search path: {search_path}, or in module 'prospector_profile_{module_name}'
 """
             )
             sys.exit(1)
         else:
             return profile, strictness
 
-    def _find_used_libraries(self, config, profile):
+    def _find_used_libraries(self, config: setoptconf.config.Configuration, profile: ProspectorProfile) -> list[str]:
         libraries = []
 
         # Bring in adaptors that we automatically detect are needed
@@ -222,7 +236,7 @@ Search path: {search_path}, or in module 'prospector_profile_{profile}'
 
         return libraries
 
-    def _determine_tool_runners(self, config, profile):
+    def _determine_tool_runners(self, config: setoptconf.config.Configuration, profile: ProspectorProfile) -> list[str]:
         if config.tools is None:
             # we had no command line settings for an explicit list of
             # tools, so we use the defaults
@@ -255,7 +269,9 @@ Search path: {search_path}, or in module 'prospector_profile_{profile}'
 
         return sorted(list(to_run))
 
-    def _determine_ignores(self, config, profile, libraries):
+    def _determine_ignores(
+        self, config: setoptconf.config.Configuration, profile: ProspectorProfile, libraries: list[str]
+    ) -> list[re.Pattern[str]]:
         # Grab ignore patterns from the options
         ignores = []
         for pattern in config.ignore_patterns + profile.ignore_patterns:
@@ -265,10 +281,8 @@ Search path: {search_path}, or in module 'prospector_profile_{profile}'
                 #  ignore-patterns:
                 #  uses: django
                 continue
-            try:
+            with contextlib.suppress(sre_constants.error):
                 ignores.append(re.compile(pattern))
-            except sre_constants.error:
-                pass
 
         # Convert ignore paths into patterns
         boundary = r"(^|/|\\)%s(/|\\|$)"
@@ -284,7 +298,7 @@ Search path: {search_path}, or in module 'prospector_profile_{profile}'
 
         return ignores
 
-    def get_summary_information(self):
+    def get_summary_information(self) -> dict[str, Any]:
         return {
             "libraries": self.libraries,
             "strictness": self.strictness,
@@ -292,64 +306,67 @@ Search path: {search_path}, or in module 'prospector_profile_{profile}'
             "tools": self.tools_to_run,
         }
 
-    def exit_with_zero_on_success(self):
+    def exit_with_zero_on_success(self) -> bool:
         return self.config.zero_exit
 
-    def get_disabled_messages(self, tool_name):
+    def get_disabled_messages(self, tool_name: str) -> list[str]:
         return self.profile.get_disabled_messages(tool_name)
 
-    def use_external_config(self, _):
+    def get_enabled_messages(self, tool_name: str) -> list[str]:
+        return self.profile.get_enabled_messages(tool_name)
+
+    def use_external_config(self, _: Any) -> bool:
         # Currently there is only one single global setting for whether to use
         # global config, but this could be extended in the future
         return not self.config.no_external_config
 
-    def tool_options(self, tool_name):
+    def tool_options(self, tool_name: str) -> dict[str, Any]:
         tool = getattr(self.profile, tool_name, None)
         if tool is None:
             return {}
         return tool.get("options", {})
 
-    def external_config_location(self, tool_name):
-        return getattr(self.config, "%s_config_file" % tool_name, None)
+    def external_config_location(self, tool_name: str) -> Optional[Path]:
+        return getattr(self.config, f"{tool_name}_config_file", None)
 
     @property
-    def die_on_tool_error(self):
+    def die_on_tool_error(self) -> bool:
         return self.config.die_on_tool_error
 
     @property
-    def summary_only(self):
+    def summary_only(self) -> bool:
         return self.config.summary_only
 
     @property
-    def messages_only(self):
+    def messages_only(self) -> bool:
         return self.config.messages_only
 
     @property
-    def quiet(self):
+    def quiet(self) -> bool:
         return self.config.quiet
 
     @property
-    def blending(self):
+    def blending(self) -> bool:
         return self.config.blending
 
     @property
-    def absolute_paths(self):
+    def absolute_paths(self) -> bool:
         return self.config.absolute_paths
 
     @property
-    def max_line_length(self):
+    def max_line_length(self) -> int:
         return self.config.max_line_length
 
     @property
-    def include_tool_stdout(self):
+    def include_tool_stdout(self) -> bool:
         return self.config.include_tool_stdout
 
     @property
-    def direct_tool_stdout(self):
+    def direct_tool_stdout(self) -> bool:
         return self.config.direct_tool_stdout
 
     @property
-    def show_profile(self):
+    def show_profile(self) -> bool:
         return self.config.show_profile
 
     @property

prospector/config/configuration.py

@@ -1,5 +1,5 @@
-# flake8: noqa
 import importlib.metadata
+from typing import Optional
 
 import setoptconf as soc
 
@@ -12,7 +12,7 @@ __all__ = ("build_manager",)
 _VERSION = importlib.metadata.version("prospector")
 
 
-def build_manager():
+def build_manager() -> soc.ConfigurationManager:
     manager = soc.ConfigurationManager("prospector")
 
     manager.add(soc.BooleanSetting("zero_exit", default=False))
@@ -77,7 +77,7 @@ def build_manager():
     return manager
 
 
-def build_default_sources():
+def build_default_sources() -> list[soc.Source]:
     sources = [
         build_command_line_source(),
         soc.EnvironmentVariableSource(),
@@ -99,7 +99,9 @@ def build_default_sources():
     return sources
 
 
-def build_command_line_source(prog=None, description="Performs static analysis of Python code"):
+def build_command_line_source(
+    prog: Optional[str] = None, description: Optional[str] = "Performs static analysis of Python code"
+) -> soc.CommandLineSource:
     parser_options = {}
     if prog is not None:
         parser_options["prog"] = prog
@@ -184,9 +186,10 @@ def build_command_line_source(prog=None, description="Performs static analysis o
         },
         "output_format": {
             "flags": ["-o", "--output-format"],
-            "help": "The output format. Valid values are: %s. This will output to stdout by default, "
-            "however a target file can be used instead by adding :path-to-output-file, eg, -o json:output.json"
-            % (", ".join(sorted(FORMATTERS.keys())),),
+            "help": "The output format. Valid values are: {}. This will output to stdout by default, "
+            "however a target file can be used instead by adding :path-to-output-file, eg, -o json:output.json".format(
+                ", ".join(sorted(FORMATTERS.keys()))
+            ),
         },
         "absolute_paths": {
             "help": "Whether to output absolute paths when referencing files "
@@ -197,9 +200,8 @@ def build_command_line_source(prog=None, description="Performs static analysis o
             "flags": ["-t", "--tool"],
             "help": "A list of tools to run. This lets you set exactly which "
             "tools to run. To add extra tools to the defaults, see "
-            "--with-tool. Possible values are: %s. By "
-            "default, the following tools will be run: %s"
-            % (
+            "--with-tool. Possible values are: {}. By "
+            "default, the following tools will be run: {}".format(
                 ", ".join(sorted(TOOLS.keys())),
                 ", ".join(sorted(DEFAULT_TOOLS)),
             ),
@@ -208,14 +210,14 @@ def build_command_line_source(prog=None, description="Performs static analysis o
             "flags": ["-w", "--with-tool"],
             "help": "A list of tools to run in addition to the default tools. "
             "To specify all tools explicitly, use the --tool argument. "
-            "Possible values are %s." % (", ".join(sorted(TOOLS.keys()))),
+            "Possible values are {}.".format(", ".join(sorted(TOOLS.keys()))),
         },
         "without_tools": {
             "flags": ["-W", "--without-tool"],
             "help": "A list of tools that should not be run. Useful to turn off "
             "only a single tool from the defaults. "
             "To specify all tools explicitly, use the --tool argument. "
-            "Possible values are %s." % (", ".join(sorted(TOOLS.keys()))),
+            "Possible values are {}.".format(", ".join(sorted(TOOLS.keys()))),
         },
         "profiles": {
             "flags": ["-P", "--profile"],

prospector/config/datatype.py

@@ -6,7 +6,7 @@ from setoptconf.datatype import Choice
 
 
 class OutputChoice(Choice):
-    def sanitize(self, value):
+    def sanitize(self, value: str) -> tuple[str, list[str]]:
         parsed = re.split(r"[;:]", value)
         output_format, output_targets = parsed[0], parsed[1:]
         checked_targets = []

prospector/encoding.py

@@ -7,8 +7,8 @@ from prospector.exceptions import CouldNotHandleEncoding, PermissionMissing
 #       mypy complains with 'Incompatible return value type (got "str", expected "bytes")'
 
 
-def read_py_file(filepath: Path):
-    # see https://docs.python.org/3/library/tokenize.html#tokenize.detect_encoding
+def read_py_file(filepath: Path) -> str:
+    # See https://docs.python.org/3/library/tokenize.html#tokenize.detect_encoding
     # first just see if the file is properly encoded
     try:
         with open(filepath, "rb") as bfile_:

prospector/exceptions.py

@@ -8,7 +8,6 @@ class FatalProspectorException(Exception):
     Problems in prospector itself should raise this to notify
     the user directly. Errors in dependent tools should be
     caught and the user notified elegantly.
-
     """
 
     # (see also the --die-on-tool-error flag)
@@ -27,10 +26,7 @@ class CouldNotHandleEncoding(Exception):
 class PermissionMissing(Exception):
     def __init__(self, path: Path):
         docs_url = "https://prospector.landscape.io/en/master/profiles.html#ignoring-paths-and-patterns"
-        if os.path.isdir(path):
-            what = f"directory {path}"
-        else:
-            what = f"the file {path}"
+        what = f"directory {path}" if os.path.isdir(path) else f"the file {path}"
         error_msg = (
             f"The current user {os.getlogin()} does not have permission to open "
             f"{what}. Either fix permissions or tell prospector to skip it "

prospector/finder.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterable, Iterator
 from pathlib import Path
-from typing import Callable, Iterable, Iterator, List
+from typing import Callable, Optional
 
 from prospector.exceptions import PermissionMissing
 from prospector.pathutils import is_python_module, is_python_package, is_virtualenv
@@ -17,7 +18,7 @@ class FileFinder:
     is basically to know which files to pass to which tools to be inspected.
     """
 
-    def __init__(self, *provided_paths: Path, exclusion_filters: Iterable[Callable] = None):
+    def __init__(self, *provided_paths: Path, exclusion_filters: Optional[Iterable[Callable[[Path], bool]]] = None):
         """
         :param provided_paths:
             A list of Path objects to search for files and modules - can be either directories or files
@@ -44,7 +45,7 @@ class FileFinder:
             if path.is_dir():
                 self._provided_dirs.append(path)
 
-    def make_syspath(self) -> List[Path]:
+    def make_syspath(self) -> list[Path]:
         paths = set()
         for path in self._provided_dirs:
             paths.add(path)
@@ -55,7 +56,7 @@ class FileFinder:
     def is_excluded(self, path: Path) -> bool:
         return any(filt(path) for filt in self._exclusion_filters)
 
-    def _filter(self, paths: Iterable[Path]) -> List[Path]:
+    def _filter(self, paths: Iterable[Path]) -> list[Path]:
         return [path for path in paths if not self.is_excluded(path)]
 
     def _walk(self, directory: Path) -> Iterator[Path]:
@@ -71,7 +72,7 @@ class FileFinder:
                 yield path
 
     @property
-    def files(self) -> List[Path]:
+    def files(self) -> list[Path]:
         """
         List every individual file found from the given configuration.
 
@@ -89,7 +90,7 @@ class FileFinder:
         return self._filter(files)
 
     @property
-    def python_packages(self) -> List[Path]:
+    def python_packages(self) -> list[Path]:
         """
         Lists every directory found in the given configuration which is a python module (that is,
         contains an `__init__.py` file).
@@ -99,7 +100,7 @@ class FileFinder:
         return self._filter(d for d in self.directories if is_python_package(d))
 
     @property
-    def python_modules(self) -> List[Path]:
+    def python_modules(self) -> list[Path]:
         """
         Lists every directory found in the given configuration which is a python module (that is,
         contains an `__init__.py` file).
@@ -109,7 +110,7 @@ class FileFinder:
         return self._filter(f for f in self.files if is_python_module(f))
 
     @property
-    def directories(self) -> List[Path]:
+    def directories(self) -> list[Path]:
         """
         Lists every directory found from the given configuration, regardless of its contents.
 

prospector/formatters/__init__.py

@@ -4,7 +4,7 @@ from .base import Formatter
 __all__ = ("FORMATTERS", "Formatter")
 
 
-FORMATTERS = {
+FORMATTERS: dict[str, type[Formatter]] = {
     "json": json.JsonFormatter,
     "text": text.TextFormatter,
     "grouped": grouped.GroupedFormatter,