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

prospector/tools/bandit/__init__.py

@@ -1,49 +1,61 @@
+from typing import TYPE_CHECKING, Any, Optional
+
 from bandit.cli.main import _get_profile, _init_extensions
 from bandit.core.config import BanditConfig
 from bandit.core.constants import RANKING
 from bandit.core.manager import BanditManager
 
+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 BanditTool(ToolBase):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.manager = None
-        self.profile = None
-        self.config_file = None
-        self.agg_type = "file"
-        self.severity = 0
-        self.confidence = 0
-
-    def configure(self, prospector_config, _):
+    manager: Optional[BanditManager] = None
+    profile: Optional[str] = None
+    config_file: Optional[str] = None
+    agg_type = "file"
+    severity = 0
+    confidence = 0
+
+    def configure(self, prospector_config: "ProspectorConfig", _: Any) -> None:
         options = prospector_config.tool_options("bandit")
 
         if "profile" in options:
-            self.profile = options["profile"]
+            self.profile = options.pop("profile")
 
         if "config" in options:
-            self.config_file = options["config"]
+            self.config_file = options.pop("config")
 
         if "severity" in options:
-            self.severity = options["severity"]
+            self.severity = options.pop("severity")
             if not 0 <= self.severity <= 2:
                 raise ValueError(f"severity {self.severity!r} must be between 0 and 2")
 
         if "confidence" in options:
-            self.confidence = options["confidence"]
+            self.confidence = options.pop("confidence")
             if not 0 <= self.confidence <= 2:
                 raise ValueError(f"confidence {self.confidence!r} must be between 0 and 2")
 
         b_conf = BanditConfig(config_file=self.config_file)
+        disabled_messages = prospector_config.get_disabled_messages("bandit")
+        if disabled_messages:
+            b_conf.config.setdefault("skips", []).extend(disabled_messages)
+        if options:
+            b_conf.config.update(options)
+            b_conf.validate(path="<prospector config>")
         profile = _get_profile(b_conf, self.profile, self.config_file)
         extension_mgr = _init_extensions()
         extension_mgr.validate_profile(profile)
 
         self.manager = BanditManager(b_conf, None, profile=profile)
 
-    def run(self, found_files):
+    def run(self, found_files: FileFinder) -> list[Message]:
+        assert self.manager is not None
+
         self.manager.files_list = sorted(found_files.files)
         self.manager.exclude_files = []
 

prospector/tools/base.py

@@ -1,12 +1,20 @@
 from abc import ABC, abstractmethod
-from typing import Iterable, List, Optional, Tuple
+from collections.abc import Iterable
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
 
+from prospector.finder import FileFinder
 from prospector.message import Message
 
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
 
 class ToolBase(ABC):
     @abstractmethod
-    def configure(self, prospector_config, found_files) -> Tuple[str, Optional[Iterable[Message]]]:
+    def configure(
+        self, prospector_config: "ProspectorConfig", found_files: FileFinder
+    ) -> Optional[tuple[Optional[Union[str, Path]], Optional[Iterable[Message]]]]:
         """
         Tools have their own way of being configured from configuration files
         on the current path - for example, a .pep8rc file. Prospector will use
@@ -25,7 +33,7 @@ class ToolBase(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def run(self, found_files) -> List[Message]:
+    def run(self, found_files: FileFinder) -> list[Message]:
         """
         Actually run the tool and collect the various messages emitted by the tool.
         It is expected that this will convert whatever output of the tool into the

prospector/tools/dodgy/__init__.py

@@ -1,5 +1,6 @@
 import mimetypes
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from dodgy.checks import check_file_contents
 
@@ -8,18 +9,21 @@ 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
 
-def module_from_path(path: Path):
+
+def module_from_path(path: Path) -> str:
     # TODO hacky...
     return ".".join(path.parts[1:-1] + (path.stem,))
 
 
 class DodgyTool(ToolBase):
-    def configure(self, prospector_config, found_files):
+    def configure(self, prospector_config: "ProspectorConfig", found_files: FileFinder) -> None:
         # empty: just implementing to satisfy the ABC contract
         pass
 
-    def run(self, found_files: FileFinder):
+    def run(self, found_files: FileFinder) -> list[Message]:
         warnings = []
         for filepath in found_files.files:
             mimetype = mimetypes.guess_type(str(filepath.absolute()))

prospector/tools/mccabe/__init__.py

@@ -1,28 +1,33 @@
 import ast
+from typing import TYPE_CHECKING, Any
 
 from mccabe import PathGraphingAstVisitor
 
 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
+
 __all__ = ("McCabeTool",)
 
 
 class McCabeTool(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] = []
         self.max_complexity = 10
 
-    def configure(self, prospector_config, _):
+    def configure(self, prospector_config: "ProspectorConfig", _: Any) -> None:
         self.ignore_codes = prospector_config.get_disabled_messages("mccabe")
 
         options = prospector_config.tool_options("mccabe")
         if "max-complexity" in options:
             self.max_complexity = options["max-complexity"]
 
-    def run(self, found_files):
+    def run(self, found_files: FileFinder) -> list[Message]:
         messages = []
 
         for code_file in found_files.python_modules:
@@ -38,7 +43,9 @@ class McCabeTool(ToolBase):
                         code_file,
                         "mccabe",
                         "MC0000",
-                        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
@@ -77,5 +84,5 @@ class McCabeTool(ToolBase):
 
         return self.filter_messages(messages)
 
-    def filter_messages(self, messages):
+    def filter_messages(self, messages: list[Message]) -> list[Message]:
         return [message for message in messages if message.code not in self.ignore_codes]

prospector/tools/mypy/__init__.py

@@ -1,7 +1,9 @@
 from multiprocessing import Process, Queue
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from mypy import api
 
+from prospector.finder import FileFinder
 from prospector.message import Location, Message
 from prospector.tools import ToolBase
 
@@ -9,30 +11,20 @@ __all__ = ("MypyTool",)
 
 from prospector.tools.exceptions import BadToolConfig
 
-LIST_OPTIONS = ["allow", "check", "disallow", "no-check", "no-warn", "warn"]
-VALID_OPTIONS = LIST_OPTIONS + [
-    "use-dmypy",
-    "strict",
-    "follow-imports",
-    "ignore-missing-imports",
-    "implicit-optional",
-    "strict-optional",
-    "platform",
-    "python-2-mode",
-    "python-version",
-    "namespace-packages",
-]
-
-
-def format_message(message):
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
+
+def format_message(message: str) -> Message:
+    character: Optional[int]
     try:
-        (path, line, char, err_type, err_msg) = message.split(":", 4)
-        line = int(line)
-        character = int(char)
+        (path, line_str, char_str, err_type, err_msg) = message.split(":", 4)
+        line = int(line_str)
+        character = int(char_str)
     except ValueError:
         try:
-            (path, line, err_type, err_msg) = message.split(":", 3)
-            line = int(line)
+            (path, line_str, err_type, err_msg) = message.split(":", 3)
+            line = int(line_str)
             character = None
         except ValueError:
             (path, err_type, err_msg) = message.split(":", 2)
@@ -53,7 +45,9 @@ def format_message(message):
     )
 
 
-def _run_in_subprocess(q, cmd, paths):
+def _run_in_subprocess(
+    q: "Queue[tuple[str, str]]", cmd: Callable[[list[str]], tuple[str, str]], paths: list[str]
+) -> None:
     """
     This function exists only to be called by multiprocessing.Process as using
     lambda is forbidden
@@ -62,72 +56,46 @@ def _run_in_subprocess(q, cmd, paths):
 
 
 class MypyTool(ToolBase):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.checker = api
         self.options = ["--show-column-numbers", "--no-error-summary"]
         self.use_dmypy = False
 
-    def configure(self, prospector_config, _):
+    def configure(self, prospector_config: "ProspectorConfig", _: Any) -> None:
         options = prospector_config.tool_options("mypy")
 
-        for option_key in options.keys():
-            if option_key not in VALID_OPTIONS:
-                url = "https://github.com/PyCQA/prospector/blob/master/prospector/tools/mypy/__init__.py"
-                raise BadToolConfig(
-                    "mypy", f"Option {option_key} is not valid. " f"See the list of possible options: {url}"
-                )
-
-        self.use_dmypy = options.get("use-dmypy", False)
-
-        strict = options.get("strict", False)
-
-        follow_imports = options.get("follow-imports", "normal")
-        ignore_missing_imports = options.get("ignore-missing-imports", False)
-        implict_optional = options.get("implict-optional", False)
-        platform = options.get("platform", None)
-        python_2_mode = options.get("python-2-mode", False)
-        python_version = options.get("python-version", None)
-        strict_optional = options.get("strict-optional", False)
-        namespace_packages = options.get("namespace-packages", False)
-
-        self.options.append(f"--follow-imports={follow_imports}")
-
-        if strict:
-            self.options.append("--strict")
-
-        if ignore_missing_imports:
-            self.options.append("--ignore-missing-imports")
-
-        if implict_optional:
-            self.options.append("--implict-optional")
-
-        if platform:
-            self.options.append(f"--platform {platform}")
-
-        if python_2_mode:
-            self.options.append("--py2")
-
-        if python_version:
-            self.options.append(f"--python-version {python_version}")
-
-        if strict_optional:
-            self.options.append("--strict-optional")
-
-        if namespace_packages:
-            self.options.append("--namespace-packages")
-
-        for list_option in LIST_OPTIONS:
-            for entry in options.get(list_option, []):
-                self.options.append(f"--{list_option}-{entry}")
-
-    def run(self, found_files):
+        self.use_dmypy = options.pop("use-dmypy", False)
+
+        # For backward compatibility
+        if "follow-imports" not in options:
+            options["follow-imports"] = "normal"
+        if "python-2-mode" in options and "py2" not in options:
+            options["py2"] = options.pop("python-2-mode")
+
+        for name, value in options.items():
+            if value is False:
+                continue
+            if value is True:
+                self.options.append(f"--{name}")
+                continue
+            if isinstance(value, (int, float, str)):
+                self.options.append(f"--{name}={value}")
+                continue
+            if isinstance(value, list):
+                for v in value:
+                    self.options.append(f"--{name}-{v}")
+                continue
+
+            raise BadToolConfig("mypy", f"The option {name} has an unsupported balue type: {type(value)}")
+
+    def run(self, found_files: FileFinder) -> list[Message]:
         paths = [str(path) for path in found_files.python_modules]
         paths.extend(self.options)
         if self.use_dmypy:
             # Due to dmypy messing with stdout/stderr we call it in a separate
             # process
-            q = Queue(1)
+            q: Queue[str] = Queue(1)
             p = Process(target=_run_in_subprocess, args=(q, self.checker.run_dmypy, ["run", "--"] + paths))
             p.start()
             result = q.get()

prospector/tools/profile_validator/__init__.py

@@ -1,17 +1,23 @@
 import re
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+from prospector.tools.base import ToolBase
 
 try:  # Python >= 3.11
     import re._constants as sre_constants
 except ImportError:
-    import sre_constants
+    import sre_constants  # pylint: disable=deprecated-module
 
 import yaml
 
 from prospector.finder import FileFinder
 from prospector.message import Location, Message
 from prospector.profiles import AUTO_LOADED_PROFILES
-from prospector.tools import DEPRECATED_TOOL_NAMES, TOOLS, ToolBase, pyflakes
+
+if TYPE_CHECKING:
+    from prospector.config import ProspectorConfig
+
 
 PROFILE_IS_EMPTY = "profile-is-empty"
 CONFIG_SETTING_SHOULD_BE_LIST = "should-be-list"
@@ -26,7 +32,9 @@ CONFIG_DEPRECATED_CODE = "deprecated-tool-code"
 __all__ = ("ProfileValidationTool",)
 
 
-def _tool_names(with_deprecated: bool = True):
+def _tool_names(with_deprecated: bool = True) -> list[str]:
+    from prospector.tools import DEPRECATED_TOOL_NAMES, TOOLS  # pylint: disable=import-outside-toplevel
+
     tools = list(TOOLS)
     if with_deprecated:
         tools += DEPRECATED_TOOL_NAMES.keys()
@@ -49,27 +57,27 @@ class ProfileValidationTool(ToolBase):
     )
     ALL_SETTINGS = LIST_SETTINGS + BOOL_SETTINGS + OTHER_SETTINGS
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.to_check = set(AUTO_LOADED_PROFILES)
-        self.ignore_codes = ()
+        self.ignore_codes: list[str] = []
 
-    def configure(self, prospector_config, found_files):
+    def configure(self, prospector_config: "ProspectorConfig", found_files: FileFinder) -> None:
         for profile in prospector_config.config.profiles:
             self.to_check.add(profile)
 
         self.ignore_codes = prospector_config.get_disabled_messages("profile-validator")
 
-    def validate(self, filepath: Path):  # noqa
+    def validate(self, filepath: Path) -> list[Message]:
         # pylint: disable=too-many-locals
         # TODO: this should be broken down into smaller pieces
-        messages = []
+        messages: list[Message] = []
 
         with filepath.open() as profile_file:
             _file_contents = profile_file.read()
             parsed = yaml.safe_load(_file_contents)
             raw_contents = _file_contents.split("\n")
 
-        def add_message(code, message, setting):
+        def add_message(code: str, message: str, setting: str) -> None:
             if code in self.ignore_codes:
                 return
             line = -1
@@ -77,9 +85,8 @@ class ProfileValidationTool(ToolBase):
                 if setting in fileline:
                     line = number + 1
                     break
-            location = Location(filepath, None, None, line, 0, False)
-            message = Message("profile-validator", code, location, message)
-            messages.append(message)
+            location = Location(filepath, None, None, line, 0)
+            messages.append(Message("profile-validator", code, location, message))
 
         if parsed is None:
             # this happens if a completely empty profile is found
@@ -159,7 +166,7 @@ class ProfileValidationTool(ToolBase):
             if not isinstance(parsed[key], (tuple, list)):
                 add_message(CONFIG_SETTING_SHOULD_BE_LIST, f'"{key}" should be a list', key)
 
-        for key in parsed.keys():
+        for key in parsed:
             if key not in ProfileValidationTool.ALL_SETTINGS and key not in _tool_names():
                 add_message(
                     CONFIG_UNKNOWN_SETTING,
@@ -170,7 +177,7 @@ class ProfileValidationTool(ToolBase):
         if "pep257" in parsed:
             add_message(
                 CONFIG_DEPRECATED_CODE,
-                "pep257 tool has been renamed to 'pydocstyle'. " "The name pep257 will be removed in prospector 2.0+.",
+                "pep257 tool has been renamed to 'pydocstyle'. The name pep257 will be removed in prospector 2.0+.",
                 "pep257",
             )
 
@@ -191,6 +198,8 @@ class ProfileValidationTool(ToolBase):
                 )
 
         if "pyflakes" in parsed:
+            from prospector.tools import pyflakes  # pylint: disable=import-outside-toplevel
+
             for code in parsed["pyflakes"].get("enable", []) + parsed["pyflakes"].get("disable", []):
                 if code in pyflakes.LEGACY_CODE_MAP:
                     _legacy = pyflakes.LEGACY_CODE_MAP[code]
@@ -202,7 +211,7 @@ class ProfileValidationTool(ToolBase):
 
         return messages
 
-    def run(self, found_files: FileFinder):
+    def run(self, found_files: FileFinder) -> list[Message]:
         messages = []
         for filepath in found_files.files:
             for possible in self.to_check:

prospector/tools/pycodestyle/__init__.py

@@ -1,6 +1,9 @@
 import codecs
 import os
 import re
+from collections.abc import Iterable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from pep8ext_naming import NamingChecker
 from pycodestyle import PROJECT_CONFIG, USER_CONFIG, BaseReport, StyleGuide, register_check
@@ -9,15 +12,18 @@ 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
+
 __all__ = ("PycodestyleTool",)
 
 
 class ProspectorReport(BaseReport):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self._prospector_messages = []
+        self._prospector_messages: list[Message] = []
 
-    def error(self, line_number, offset, text, check):
+    def error(self, line_number: Optional[int], offset: int, text: str, check: str) -> None:
         code = super().error(
             line_number,
             offset,
@@ -53,12 +59,12 @@ class ProspectorReport(BaseReport):
 
         self._prospector_messages.append(message)
 
-    def get_messages(self):
+    def get_messages(self) -> list[Message]:
         return self._prospector_messages
 
 
 class ProspectorStyleGuide(StyleGuide):
-    def __init__(self, config, found_files, *args, **kwargs):
+    def __init__(self, config: "ProspectorConfig", found_files: FileFinder, *args: Any, **kwargs: Any) -> None:
         self._config = config
         self._files = found_files
         self._module_paths = found_files.python_modules
@@ -68,7 +74,7 @@ class ProspectorStyleGuide(StyleGuide):
 
         super().__init__(*args, **kwargs)
 
-    def excluded(self, filename, parent=None):
+    def excluded(self, filename: str, parent: Optional[str] = None) -> bool:
         if super().excluded(filename, parent):
             return True
 
@@ -82,11 +88,11 @@ class ProspectorStyleGuide(StyleGuide):
 
 
 class PycodestyleTool(ToolBase):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.checker = None
+    checker: Optional[ProspectorStyleGuide] = None
 
-    def configure(self, prospector_config, found_files: FileFinder):
+    def configure(
+        self, prospector_config: "ProspectorConfig", found_files: FileFinder
+    ) -> Optional[tuple[Optional[str], Optional[Iterable[Message]]]]:
         # figure out if we should use a pre-existing config file
         # such as setup.cfg or tox.ini
         external_config = None
@@ -97,18 +103,18 @@ class PycodestyleTool(ToolBase):
         if prospector_config.use_external_config("pycodestyle"):
             use_config = True
 
-            paths = [os.path.join(prospector_config.workdir, name) for name in PROJECT_CONFIG]
+            paths: list[Union[str, Path]] = [os.path.join(prospector_config.workdir, name) for name in PROJECT_CONFIG]
             paths.append(USER_CONFIG)
             ext_loc = prospector_config.external_config_location("pycodestyle")
             if ext_loc is not None:
-                paths = [ext_loc] + paths
+                paths = [ext_loc] + paths  # type: ignore[assignment,operator]
 
             for conf_path in paths:
                 if os.path.exists(conf_path) and os.path.isfile(conf_path):
                     # this file exists - but does it have pep8 or pycodestyle config in it?
                     # TODO: Remove this
                     header = re.compile(r"\[(pep8|pycodestyle)\]")
-                    with codecs.open(conf_path) as conf_file:
+                    with codecs.open(str(conf_path)) as conf_file:
                         if any(header.search(line) for line in conf_file.readlines()):
                             external_config = conf_path
                             break
@@ -133,7 +139,7 @@ class PycodestyleTool(ToolBase):
             if "max-line-length" in prospector_config.tool_options("pycodestyle"):
                 self.checker.options.max_line_length = prospector_config.tool_options("pycodestyle")["max-line-length"]
         else:
-            configured_by = "Configuration found at %s" % external_config
+            configured_by = f"Configuration found at {external_config}"
 
         # if we have a command line --max-line-length argument, that
         # overrules everything
@@ -143,7 +149,8 @@ class PycodestyleTool(ToolBase):
 
         return configured_by, []
 
-    def run(self, _):
+    def run(self, _: Any) -> list[Message]:
+        assert self.checker is not None
         report = self.checker.check_files()
         return report.get_messages()
 

prospector/tools/pydocstyle/__init__.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING, Any
+
 from pydocstyle.checker import AllError, ConventionChecker
 
 from prospector.encoding import CouldNotHandleEncoding, read_py_file
@@ -5,19 +7,23 @@ 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
+
+
 __all__ = ("PydocstyleTool",)
 
 
 class PydocstyleTool(ToolBase):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self._code_files = []
-        self.ignore_codes = ()
+        self._code_files: list[str] = []
+        self.ignore_codes: list[str] = []
 
-    def configure(self, prospector_config, found_files):
+    def configure(self, prospector_config: "ProspectorConfig", found_files: FileFinder) -> None:
         self.ignore_codes = prospector_config.get_disabled_messages("pydocstyle")
 
-    def run(self, found_files: FileFinder):
+    def run(self, found_files: FileFinder) -> list[Message]:
         messages = []
 
         checker = ConventionChecker()
@@ -61,5 +67,5 @@ class PydocstyleTool(ToolBase):
 
         return self.filter_messages(messages)
 
-    def filter_messages(self, messages):
+    def filter_messages(self, messages: list[Message]) -> list[Message]:
         return [message for message in messages if message.code not in self.ignore_codes]