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

prospector/formatters/base.py

@@ -1,33 +1,38 @@
 from abc import ABC, abstractmethod
 
+from prospector.profiles.profile import ProspectorProfile
+
 __all__ = ("Formatter",)
 
 from pathlib import Path
+from typing import Any, Optional
 
-from prospector.message import Message
+from prospector.message import Location, Message
 
 
 class Formatter(ABC):
-    def __init__(self, summary, messages, profile, paths_relative_to: Path = None):
+    def __init__(
+        self,
+        summary: dict[str, Any],
+        messages: list[Message],
+        profile: ProspectorProfile,
+        paths_relative_to: Optional[Path] = None,
+    ) -> None:
         self.summary = summary
         self.messages = messages
         self.profile = profile
         self.paths_relative_to = paths_relative_to
 
     @abstractmethod
-    def render(self, summary=True, messages=True, profile=False):
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
         raise NotImplementedError
 
-    def _make_path(self, path: Path) -> str:
-        if self.paths_relative_to is None:
-            path = path.absolute()
-        elif path.is_absolute():
-            path = path.relative_to(self.paths_relative_to)
-        return str(path)
+    def _make_path(self, location: Location) -> Path:
+        return location.relative_path(self.paths_relative_to)
 
-    def _message_to_dict(self, message: Message) -> dict:
+    def _message_to_dict(self, message: Message) -> dict[str, Any]:
         loc = {
-            "path": self._make_path(message.location.path),
+            "path": str(self._make_path(message.location)),
             "module": message.location.module,
             "function": message.location.function,
             "line": message.location.line,

prospector/formatters/base_summary.py

@@ -0,0 +1,43 @@
+from prospector.formatters.base import Formatter
+
+
+class SummaryFormatter(Formatter):
+    """
+    This abstract formatter is used to output a summary of the prospector run.
+    """
+
+    summary_labels = (
+        ("started", "Started", None),
+        ("completed", "Finished", None),
+        ("time_taken", "Time Taken", lambda x: f"{x} seconds"),
+        ("formatter", "Formatter", None),
+        ("profiles", "Profiles", None),
+        ("strictness", "Strictness", None),
+        ("libraries", "Libraries Used", ", ".join),
+        ("tools", "Tools Run", ", ".join),
+        ("adaptors", "Adaptors", ", ".join),
+        ("message_count", "Messages Found", None),
+        ("external_config", "External Config", None),
+    )
+
+    def render_summary(self) -> str:
+        output = [
+            "Check Information",
+            "=================",
+        ]
+
+        label_width = max(len(label[1]) for label in self.summary_labels)
+
+        for key, label, formatter in self.summary_labels:
+            if key in self.summary:
+                value = self.summary[key]
+                if formatter is not None:
+                    value = formatter(value)
+                output.append(f" {label.rjust(label_width)}: {value}")
+
+        return "\n".join(output)
+
+    def render_profile(self) -> str:
+        output = ["Profile", "=======", "", self.profile.as_yaml().strip()]
+
+        return "\n".join(output)

prospector/formatters/emacs.py

@@ -1,26 +1,26 @@
 from prospector.formatters.text import TextFormatter
+from prospector.message import Message
 
 __all__ = ("EmacsFormatter",)
 
 
 class EmacsFormatter(TextFormatter):
-    def render_message(self, message):
+    def render_message(self, message: Message) -> str:
         output = [
             "%s:%s:%d:"
             % (
-                self._make_path(message.location.path),
+                self._make_path(message.location),
                 message.location.line,
                 (message.location.character or 0) + 1,
             ),
-            "    L%s:%s %s: %s - %s"
-            % (
+            "    L{}:{} {}: {} - {}".format(
                 message.location.line or "-",
                 message.location.character if message.location.line else "-",
                 message.location.function,
                 message.source,
                 message.code,
             ),
-            "    %s" % message.message,
+            f"    {message.message}",
         ]
 
         return "\n".join(output)

prospector/formatters/grouped.py

@@ -1,37 +1,39 @@
 from collections import defaultdict
+from pathlib import Path
 
 from prospector.formatters.text import TextFormatter
+from prospector.message import Message
 
 __all__ = ("GroupedFormatter",)
 
 
 class GroupedFormatter(TextFormatter):
-    def render_messages(self):
+    def render_messages(self) -> str:
         output = [
             "Messages",
             "========",
             "",
         ]
 
-        groups = defaultdict(lambda: defaultdict(list))
+        groups: dict[Path, dict[int, list[Message]]] = defaultdict(lambda: defaultdict(list))
 
         for message in self.messages:
-            groups[self._make_path(message.location.path)][message.location.line].append(message)
+            assert message.location.line is not None
+            groups[self._make_path(message.location)][message.location.line].append(message)
 
         for filename in sorted(groups.keys()):
             output.append(str(filename))
 
             for line in sorted(groups[filename].keys(), key=lambda x: 0 if x is None else int(x)):
-                output.append("  Line: %s" % line)
+                output.append(f"  Line: {line}")
 
                 for message in groups[filename][line]:
                     output.append(
-                        "    %s: %s / %s%s"
-                        % (
+                        "    {}: {} / {}{}".format(
                             message.source,
                             message.code,
                             message.message,
-                            (" (col %s)" % message.location.character) if message.location.character else "",
+                            (f" (col {message.location.character})") if message.location.character else "",
                         )
                     )
 

prospector/formatters/json.py

@@ -1,5 +1,6 @@
 import json
 from datetime import datetime
+from typing import Any
 
 from prospector.formatters.base import Formatter
 
@@ -7,8 +8,8 @@ __all__ = ("JsonFormatter",)
 
 
 class JsonFormatter(Formatter):
-    def render(self, summary=True, messages=True, profile=False):
-        output = {}
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
+        output: dict[str, Any] = {}
 
         if summary:
             # we need to slightly change the types and format

prospector/formatters/pylint.py

@@ -1,44 +1,67 @@
 import os
 import re
 
-from prospector.formatters.base import Formatter
+from prospector.formatters.base_summary import SummaryFormatter
 
 
-class PylintFormatter(Formatter):
+class PylintFormatter(SummaryFormatter):
     """
     This formatter outputs messages in the same way as pylint -f parseable , which is used by several
     tools to parse pylint output. This formatter is therefore a compatibility shim between tools built
     on top of pylint and prospector itself.
     """
 
-    def render(self, summary=True, messages=True, profile=False):
-        # this formatter will always ignore the summary and profile
+    def render_messages(self) -> list[str]:
         cur_loc = None
         output = []
         for message in sorted(self.messages):
             if cur_loc != message.location.path:
                 cur_loc = message.location.path
-                module_name = self._make_path(message.location.path).replace(os.path.sep, ".")
+                module_name = str(self._make_path(message.location)).replace(os.path.sep, ".")
                 module_name = re.sub(r"(\.__init__)?\.py$", "", module_name)
 
-                header = "************* Module %s" % module_name
+                header = f"************* Module {module_name}"
                 output.append(header)
 
             #   ={path}:{line}: [{msg_id}({symbol}), {obj}] {msg}
             # prospector/configuration.py:65: [missing-docstring(missing-docstring), build_default_sources] \
             # Missing function docstring
 
-            template = "%(path)s:%(line)s: [%(code)s(%(source)s), %(function)s] %(message)s"
+            template_location = (
+                "%(path)s"
+                if message.location.line is None
+                else "%(path)s:%(line)s"
+                if message.location.character is None
+                else "%(path)s:%(line)s:%(character)s"
+            )
+            template_code = (
+                "%(code)s(%(source)s)" if message.location.function is None else "[%(code)s(%(source)s), %(function)s]"
+            )
+            template = f"{template_location}: {template_code}: %(message)s"
+
             output.append(
                 template
                 % {
-                    "path": self._make_path(message.location.path),
+                    "path": self._make_path(message.location),
                     "line": message.location.line,
+                    "character": message.location.character,
                     "source": message.source,
                     "code": message.code,
                     "function": message.location.function,
                     "message": message.message.strip(),
                 }
             )
+        return output
+
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
+        output: list[str] = []
+        if messages:
+            output.extend(self.render_messages())
+        if profile:
+            output.append("")
+            output.append(self.render_profile())
+        if summary:
+            output.append("")
+            output.append(self.render_summary())
 
         return "\n".join(output)

prospector/formatters/text.py

@@ -1,63 +1,20 @@
-from prospector.formatters.base import Formatter
+from prospector.formatters.base_summary import SummaryFormatter
+from prospector.message import Message
 
 __all__ = ("TextFormatter",)
 
 
-# pylint: disable=unnecessary-lambda
-
-
-class TextFormatter(Formatter):
-    summary_labels = (
-        ("started", "Started"),
-        ("completed", "Finished"),
-        ("time_taken", "Time Taken", lambda x: "%s seconds" % x),
-        ("formatter", "Formatter"),
-        ("profiles", "Profiles"),
-        ("strictness", "Strictness"),
-        ("libraries", "Libraries Used", lambda x: ", ".join(x)),
-        ("tools", "Tools Run", lambda x: ", ".join(x)),
-        ("adaptors", "Adaptors", lambda x: ", ".join(x)),
-        ("message_count", "Messages Found"),
-        ("external_config", "External Config"),
-    )
-
-    def render_summary(self):
-        output = [
-            "Check Information",
-            "=================",
-        ]
-
-        label_width = max(len(label[1]) for label in self.summary_labels)
-
-        for summary_label in self.summary_labels:
-            key = summary_label[0]
-            if key in self.summary:
-                label = summary_label[1]
-                if len(summary_label) > 2:
-                    value = summary_label[2](self.summary[key])
-                else:
-                    value = self.summary[key]
-                output.append(
-                    " %s: %s"
-                    % (
-                        label.rjust(label_width),
-                        value,
-                    )
-                )
-
-        return "\n".join(output)
-
-    def render_message(self, message):
+class TextFormatter(SummaryFormatter):
+    def render_message(self, message: Message) -> str:
         output = []
 
         if message.location.module:
-            output.append(f"{message.location.module} ({self._make_path(message.location.path)}):")
+            output.append(f"{message.location.module} ({self._make_path(message.location)}):")
         else:
-            output.append("%s:" % self._make_path(message.location.path))
+            output.append(f"{self._make_path(message.location)}:")
 
         output.append(
-            "    L%s:%s %s: %s - %s"
-            % (
+            "    L{}:{} {}: {} - {}".format(
                 message.location.line or "-",
                 message.location.character if message.location.character else "-",
                 message.location.function,
@@ -66,11 +23,11 @@ class TextFormatter(Formatter):
             )
         )
 
-        output.append("    %s" % message.message)
+        output.append(f"    {message.message}")
 
         return "\n".join(output)
 
-    def render_messages(self):
+    def render_messages(self) -> str:
         output = [
             "Messages",
             "========",
@@ -83,12 +40,7 @@ class TextFormatter(Formatter):
 
         return "\n".join(output)
 
-    def render_profile(self):
-        output = ["Profile", "=======", "", self.profile.as_yaml().strip()]
-
-        return "\n".join(output)
-
-    def render(self, summary=True, messages=True, profile=False):
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
         output = []
         if messages and self.messages:  # if there are no messages, don't render an empty header
             output.append(self.render_messages())

prospector/formatters/vscode.py

@@ -1,26 +1,25 @@
 import os
 import re
 
-from prospector.formatters.base import Formatter
+from prospector.formatters.base_summary import SummaryFormatter
 
 
-class VSCodeFormatter(Formatter):
+class VSCodeFormatter(SummaryFormatter):
     """
     This formatter outputs messages in the same way as vscode prospector linter expects.
     """
 
-    def render(self, summary=True, messages=True, profile=False):
-        # this formatter will always ignore the summary and profile
+    def render_messages(self) -> list[str]:
         cur_loc = None
         output = []
 
         for message in sorted(self.messages):
             if cur_loc != message.location.path:
                 cur_loc = message.location.path
-                module_name = self._make_path(message.location.path).replace(os.path.sep, ".")
+                module_name = str(self._make_path(message.location)).replace(os.path.sep, ".")
                 module_name = re.sub(r"(\.__init__)?\.py$", "", module_name)
 
-                header = "************* Module %s" % module_name
+                header = f"************* Module {module_name}"
                 output.append(header)
 
             template = "%(line)s,%(character)s,%(code)s,%(code)s:%(source)s %(message)s"
@@ -34,5 +33,17 @@ class VSCodeFormatter(Formatter):
                     "message": message.message.strip(),
                 }
             )
+        return output
+
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
+        output: list[str] = []
+        if messages:
+            output.extend(self.render_messages())
+        if profile:
+            output.append("")
+            output.append(self.render_profile())
+        if summary:
+            output.append("")
+            output.append(self.render_summary())
 
         return "\n".join(output)

prospector/formatters/xunit.py

@@ -1,4 +1,4 @@
-from xml.dom.minidom import Document
+from xml.dom.minidom import Document  # nosec
 
 from prospector.formatters.base import Formatter
 
@@ -10,13 +10,13 @@ class XunitFormatter(Formatter):
     to use Xunit and prospector itself.
     """
 
-    def render(self, summary=True, messages=True, profile=False):
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
         xml_doc = Document()
 
         testsuite_el = xml_doc.createElement("testsuite")
         testsuite_el.setAttribute("errors", str(self.summary["message_count"]))
         testsuite_el.setAttribute("failures", "0")
-        testsuite_el.setAttribute("name", "prospector-%s" % "-".join(self.summary["tools"]))
+        testsuite_el.setAttribute("name", "prospector-{}".format("-".join(self.summary["tools"])))
         testsuite_el.setAttribute("tests", str(self.summary["message_count"]))
         testsuite_el.setAttribute("time", str(self.summary["time_taken"]))
         xml_doc.appendChild(testsuite_el)
@@ -34,14 +34,14 @@ class XunitFormatter(Formatter):
 
         for message in sorted(self.messages):
             testcase_el = xml_doc.createElement("testcase")
-            testcase_el.setAttribute("name", f"{self._make_path(message.location.path)}-{message.location.line}")
+            testcase_el.setAttribute("name", f"{self._make_path(message.location)}-{message.location.line}")
 
             failure_el = xml_doc.createElement("error")
             failure_el.setAttribute("message", message.message.strip())
-            failure_el.setAttribute("type", "%s Error" % message.source)
+            failure_el.setAttribute("type", f"{message.source} Error")
             template = "%(path)s:%(line)s: [%(code)s(%(source)s), %(function)s] %(message)s"
             cdata = template % {
-                "path": self._make_path(message.location.path),
+                "path": self._make_path(message.location),
                 "line": message.location.line,
                 "source": message.source,
                 "code": message.code,

prospector/formatters/yaml.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 import yaml
 
 from prospector.formatters.base import Formatter
@@ -6,8 +8,8 @@ __all__ = ("YamlFormatter",)
 
 
 class YamlFormatter(Formatter):
-    def render(self, summary=True, messages=True, profile=False):
-        output = {}
+    def render(self, summary: bool = True, messages: bool = True, profile: bool = False) -> str:
+        output: dict[str, Any] = {}
 
         if summary:
             output["summary"] = self.summary

prospector/message.py

@@ -4,12 +4,17 @@ from typing import Optional, Union
 
 class Location:
     def __init__(
-        self, path: Union[Path, str], module: Optional[str], function: Optional[str], line: int, character: int
+        self,
+        path: Union[Path, str],
+        module: Optional[str],
+        function: Optional[str],
+        line: Optional[int],
+        character: Optional[int],
     ):
         if isinstance(path, Path):
-            self._path = path
+            self._path = path.absolute()
         elif isinstance(path, str):
-            self._path = Path(path)
+            self._path = Path(path).absolute()
         else:
             raise ValueError
         self.module = module or None
@@ -18,14 +23,14 @@ class Location:
         self.character = None if character == -1 else character
 
     @property
-    def path(self):
+    def path(self) -> Path:
         return self._path
 
     def absolute_path(self) -> Path:
-        return self._path.absolute()
+        return self._path
 
-    def relative_path(self, root: Path) -> Path:
-        return self._path.relative_to(root)
+    def relative_path(self, root: Optional[Path]) -> Path:
+        return self._path.relative_to(root) if root else self._path
 
     def __repr__(self) -> str:
         return f"{self._path}:L{self.line}:{self.character}"
@@ -38,7 +43,7 @@ class Location:
             return False
         return self._path == other._path and self.line == other.line and self.character == other.character
 
-    def __lt__(self, other: object) -> bool:
+    def __lt__(self, other: "Location") -> bool:
         if not isinstance(other, Location):
             raise ValueError
         if self._path == other._path:
@@ -65,7 +70,7 @@ class Message:
             return self.code == other.code
         return False
 
-    def __lt__(self, other) -> bool:
+    def __lt__(self, other: "Message") -> bool:
         if self.location == other.location:
             return self.code < other.code
         return self.location < other.location
@@ -76,10 +81,10 @@ def make_tool_error_message(
     source: str,
     code: str,
     message: str,
-    line: int = 0,
-    character: int = 0,
-    module: str = None,
-    function: str = None,
+    line: Optional[int] = None,
+    character: Optional[int] = None,
+    module: Optional[str] = None,
+    function: Optional[str] = None,
 ) -> Message:
     location = Location(path=filepath, module=module, function=function, line=line, character=character)
     return Message(source=source, code=code, location=location, message=message)

prospector/pathutils.py

@@ -12,11 +12,7 @@ def is_python_module(path: Path) -> bool:
 
 
 def is_virtualenv(path: Path) -> bool:
-    if os.name == "nt":
-        # Windows!
-        clues = ("Scripts", "lib", "include")
-    else:
-        clues = ("bin", "lib", "include")
+    clues = ("Scripts", "lib", "include") if os.name == "nt" else ("bin", "lib", "include")
 
     try:
         # just get the name, iterdir returns absolute paths by default
@@ -37,8 +33,5 @@ def is_virtualenv(path: Path) -> bool:
     # if we do have all three directories, make sure that it's not
     # just a coincidence by doing some heuristics on the rest of
     # the directory
-    if len(dircontents) > 7:
-        # if there are more than 7 things it's probably not a virtualenvironment
-        return False
-
-    return True
+    # if there are more than 7 things it's probably not a virtualenvironment
+    return len(dircontents) <= 7

prospector/postfilter.py

@@ -42,15 +42,16 @@ def filter_messages(filepaths: List[Path], messages: List[Message]) -> List[Mess
             continue
 
         # some lines are skipped entirely by messages
-        if relative_message_path in lines_to_ignore:
-            if message.location.line in lines_to_ignore[relative_message_path]:
-                continue
+        if relative_message_path in lines_to_ignore and message.location.line in lines_to_ignore[relative_message_path]:
+            continue
 
         # and some lines have only certain messages explicitly ignored
-        if relative_message_path in messages_to_ignore:
-            if message.location.line in messages_to_ignore[relative_message_path]:
-                if message.code in messages_to_ignore[relative_message_path][message.location.line]:
-                    continue
+        if (
+            relative_message_path in messages_to_ignore
+            and message.location.line in messages_to_ignore[relative_message_path]
+            and message.code in messages_to_ignore[relative_message_path][message.location.line]
+        ):
+            continue
 
         # otherwise this message was not filtered
         filtered.append(message)

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"