MyPy & PEP 702 (@deprecated)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

import dataclasses as dc
from typing import TYPE_CHECKING
from typing import Dict, Optional
from astroid.nodes import Call, Name
from astroid.bases import Instance
from astroid import Uninferable
from pylint.checkers import BaseChecker
from pylint.checkers.utils import safe_infer
from pylint.interfaces import IAstroidChecker

if TYPE_CHECKING:
    from pylint.lint import PyLinter


@dc.dataclass
class _Deprecation:
    reason: Optional[str] = None
    version: Optional[str] = None
    type_: Optional[str] = None


class DeprecatedChecker(BaseChecker):
    __implements__ = IAstroidChecker

    name = "no-deprecated"
    priority = -1
    msgs = {
        "W0001": (
            "%s is deprecated%s; reason : %s",
            "no-deprecated",
            "Functions/Classes that have been marked via annotations "
            "as deprecated should not be used."
        )
    }

    _QNAME = "deprecated.classic.deprecated"

    def __init__(self, linter: Optional["PyLinter"] = None):
        super().__init__(linter)

        self._deprecations: Dict[str, _Deprecation] = {}

    def visit_name(self, node):
        # Not sure mandatory
        if not isinstance(node, Name):
            return

        called = safe_infer(node)

        # Avoid flagging on instanciated objects, only raising a warning
        # when instanciating/using the function/class
        if (
            called is None
            or isinstance(called, Instance)
            or not hasattr(called, "decorators")
        ):
            return

        # Check the decorators
        decorators = called.decorators.nodes if called.decorators else []

        # I think this is somehow not optimal and could be improved
        for n in decorators:
            c = None
            reason = None
            version = None

            # In case we have a call, we need to extract the thing being called
            if isinstance(n, Call):
                c = n
                n = n.func

                if c.args is not None and len(c.args) == 1:
                    reason = f"\"{c.args[0].value}\""

                # So we can extract the useful decorator data from the args or kwargs
                if c.keywords is not None:
                    for kw in c.keywords:
                        if kw.arg == "version":
                            version = f" since version \"{kw.value.value}\""
                        elif kw.arg == "reason":
                            reason = f"\"{kw.value.value}\""

            # Then, we need to check if we find the proper decorator
            for i in n.infer():
                if i is not None and i != Uninferable and i.qname() == self._QNAME:
                    self.add_message(
                        "no-deprecated",
                        node = node,
                        args = (
                            called.name,
                            version or "",
                            reason or "not specified"
                        )
                    )

                    return


def register(linter: "PyLinter"):
    linter.register_checker(DeprecatedChecker(linter))

1
2

[tool.mypy]
plugins = ["mypypp.deprecated"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

from __future__ import annotations

from typing import final

from typing_extensions import deprecated


@deprecated("This function shouldn't be used.")
def function() -> None: ...


@deprecated("This class shouldn't be used.")
@final
class Class: ...


@final
class Test:
    @deprecated("This method shouldn't be used.")
    def instance_method(self) -> None: ...

    @deprecated("This method shouldn't be used.")
    @classmethod
    def class_method(cls) -> None: ...

    @deprecated("This method shouldn't be used.")
    @staticmethod
    def static_method() -> None: ...


if __name__ == "__main__":
    function()

    _ = Class()

    Test().instance_method()
    Test().class_method()
    Test().static_method()

    Test.class_method()
    Test.static_method()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from __future__ import annotations

from definitions import Class, Test, function

if __name__ == "__main__":
    function()

    _ = Class()

    Test().instance_method()
    Test().class_method()
    Test().static_method()

    Test.class_method()
    Test.static_method()