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

prospector/tools/pyflakes/__init__.py

@@ -1,15 +1,21 @@
+from typing import TYPE_CHECKING, Any, Optional
+
 from pyflakes.api import checkPath
+from pyflakes.messages import Message as FlakeMessage
 from pyflakes.reporter import Reporter
 
+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__ = ("PyFlakesTool",)
 
 
 # Prospector uses the same pyflakes codes as flake8 defines,
 # see https://flake8.pycqa.org/en/latest/user/error-codes.html
-# and https://gitlab.com/pycqa/flake8/-/blob/e817c63a/src/flake8/plugins/pyflakes.py
+# and https://github.com/PyCQA/flake8/blob/e817c63a/src/flake8/plugins/pyflakes.py
 _MESSAGE_CODES = {
     "UnusedImport": "F401",
     "ImportShadowedByLoopVar": "F402",
@@ -81,13 +87,22 @@ LEGACY_CODE_MAP = {
 
 
 class ProspectorReporter(Reporter):
-    def __init__(self, ignore=None):
+    def __init__(self, ignore: Optional[list[str]] = None) -> None:
         super().__init__(None, None)
-        self._messages = []
+        self._messages: list[Message] = []
         self.ignore = ignore or ()
 
-    # pylint: disable=too-many-arguments
-    def record_message(self, filename=None, line=None, character=None, code=None, message=None):
+    def record_message(  # pylint: disable=too-many-arguments
+        self,
+        filename: str,
+        line: Optional[int] = None,
+        character: Optional[int] = None,
+        code: Optional[str] = None,
+        message: Optional[str] = None,
+    ) -> None:
+        assert message is not None
+        assert code is not None
+
         code = code or "F999"
         if code in self.ignore:
             return
@@ -99,15 +114,16 @@ class ProspectorReporter(Reporter):
             line=line,
             character=character,
         )
-        message = Message(
-            source="pyflakes",
-            code=code,
-            location=location,
-            message=message,
+        self._messages.append(
+            Message(
+                source="pyflakes",
+                code=code,
+                location=location,
+                message=message,
+            )
         )
-        self._messages.append(message)
 
-    def unexpectedError(self, filename, msg):  # noqa
+    def unexpectedError(self, filename: str, msg: str) -> None:
         self.record_message(
             filename=filename,
             code="F999",
@@ -115,7 +131,7 @@ class ProspectorReporter(Reporter):
         )
 
     # pylint: disable=too-many-arguments
-    def syntaxError(self, filename, msg, lineno, offset, text):  # noqa
+    def syntaxError(self, filename: str, msg: str, lineno: int, offset: int, text: str) -> None:
         self.record_message(
             filename=filename,
             line=lineno,
@@ -124,7 +140,7 @@ class ProspectorReporter(Reporter):
             message=msg,
         )
 
-    def flake(self, message):
+    def flake(self, message: FlakeMessage) -> None:
         code = _MESSAGE_CODES.get(message.__class__.__name__, "F999")
 
         self.record_message(
@@ -135,21 +151,21 @@ class ProspectorReporter(Reporter):
             message=message.message % message.message_args,
         )
 
-    def get_messages(self):
+    def get_messages(self) -> list[Message]:
         return self._messages
 
 
 class PyFlakesTool(ToolBase):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self.ignore_codes = ()
+        self.ignore_codes: list[str] = []
 
-    def configure(self, prospector_config, _):
+    def configure(self, prospector_config: "ProspectorConfig", _: Any) -> None:
         ignores = prospector_config.get_disabled_messages("pyflakes")
         # convert old style to new
         self.ignore_codes = [LEGACY_CODE_MAP.get(code, code) for code in ignores]
 
-    def run(self, found_files):
+    def run(self, found_files: FileFinder) -> list[Message]:
         reporter = ProspectorReporter(ignore=self.ignore_codes)
         for filepath in found_files.python_modules:
             checkPath(str(filepath.absolute()), reporter)

prospector/tools/pylint/__init__.py

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

prospector/tools/pylint/collector.py

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

prospector/tools/pylint/linter.py

@@ -1,34 +1,39 @@
+from collections.abc import Iterable
 from pathlib import Path
+from typing import Any, Optional, Union
 
 from packaging import version as packaging_version
 from pylint import version as pylint_version
+from pylint.config.config_initialization import _config_initialization
 from pylint.lint import PyLinter
-from pylint.utils import _splitstrip
+
+from prospector.finder import FileFinder
+
+
+class UnrecognizedOptions(Exception):
+    """Raised when an unrecognized option is found in the Pylint configuration."""
 
 
 class ProspectorLinter(PyLinter):
-    def __init__(self, found_files, *args, **kwargs):
+    def __init__(self, found_files: FileFinder, *args: Any, **kwargs: Any) -> None:
         self._files = found_files
         # set up the standard PyLint linter
         PyLinter.__init__(self, *args, **kwargs)
 
-    def config_from_file(self, config_file=None):
-        """Will return `True` if plugins have been loaded. For pylint>=1.5. Else `False`."""
-        self.read_config_file(config_file)
-        if self.cfgfile_parser.has_option("MASTER", "load-plugins"):
-            plugins = _splitstrip(self.cfgfile_parser.get("MASTER", "load-plugins"))
-            self.load_plugin_modules(plugins)
-        self.load_config_file()
+    # Largely inspired by https://github.com/pylint-dev/pylint/blob/main/pylint/config/config_initialization.py#L26
+    def config_from_file(self, config_file: Optional[Union[str, Path]] = None) -> bool:
+        """Initialize the configuration from a file."""
+        _config_initialization(self, [], config_file=config_file)
         return True
 
-    def _expand_files(self, modules):
-        expanded = super()._expand_files(modules)
-        filtered = {}
+    def _expand_files(self, files_or_modules: list[str]) -> Union[Iterable[Any], dict[str, Any]]:
+        expanded = super()._expand_files(files_or_modules)
+        filtered: dict[str, Any] = {}
         # PyLinter._expand_files returns dict since 2.15.7.
         if packaging_version.parse(pylint_version) > packaging_version.parse("2.15.6"):
-            for module in expanded:
+            for module, expanded_module in expanded.items():
                 if not self._files.is_excluded(Path(module)):
-                    filtered[module] = expanded[module]
+                    filtered[module] = expanded_module
             return filtered
         else:
             for module in expanded:

prospector/tools/pyright/__init__.py

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

prospector/tools/pyroma/__init__.py

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

prospector/tools/ruff/__init__.py

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

prospector/tools/utils.py

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