Path 1: 7494 calls (0.67)

→ node Call (7494)

→ inferred FunctionDef (4124) ClassDef (3308) AsyncFunctionDef (40) BoundMethod (20) PartialFunction (2)

10 run 11 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 2: 2965 calls (0.27)

→ node Call (2965)

→ inferred BoundMethod (1745) FunctionDef (907) ClassDef (212) UnboundMethod (80) AsyncFunctionDef (9) ClassModel.attr___subclasses__..SubclassesBoundMet...

9 run 12 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 3: 596 calls (0.05)

→ node Call (596)

→ inferred Uninferable (321) Lambda (168) Instance (50) Const (44) Slice (4) Module (2) List (2) Dict (2) Tuple (2) AssignAttr (1)

↩ return None (596)

2 run 19 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 4: 53 calls (0.0)

→ node Call (53)

→ inferred ClassDef (52) FunctionDef (1)

12 run 9 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 5: 46 calls (0.0)

→ node Call (46)

→ inferred PartialFunction (24) ClassDef (20) BoundMethod (2)

↩ return None (46)

4 run 17 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 6: 12 calls (0.0)

→ node Call (12)

→ inferred AsyncFunctionDef (7) BoundMethod (3) FunctionDef (2)

11 run 10 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 7: 7 calls (0.0)

→ node Call (7)

→ inferred BoundMethod (4) FunctionDef (3)

↩ return None (7)

⚠ exception GeneratorExit (7)

7 run 14 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 8: 3 calls (0.0)

→ node Call (3)

→ inferred FunctionDef (3)

13 run 8 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 9: 3 calls (0.0)

→ node Call (3)

→ inferred BoundMethod (3)

12 run 9 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 10: 2 calls (0.0)

→ node Call (2)

→ inferred FunctionDef (1) ClassDef (1)

14 run 7 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 11: 1 calls (0.0)

→ node Call (1)

→ inferred FunctionDef (1)

↩ return None (1)

⚠ exception GeneratorExit (1)

8 run 13 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 12: 1 calls (0.0)

→ node Call (1)

→ inferred BoundMethod (1)

13 run 8 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 13: 1 calls (0.0)

→ node Call (1)

→ inferred FunctionDef (1)

16 run 5 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )
            

Path 14: 1 calls (0.0)

→ node Call (1)

→ inferred BoundMethod (1)

15 run 6 not run

1def check_deprecated_method(self, node: nodes.Call, inferred: nodes.NodeNG) -> None:
2        """Executes the checker for the given node.
3
4        This method should be called from the checker implementing this mixin.
5        """
6
7        # Reject nodes which aren't of interest to us.
8        if not isinstance(inferred, ACCEPTABLE_NODES):
9            return
10
11        if isinstance(node.func, nodes.Attribute):
12            func_name = node.func.attrname
13        elif isinstance(node.func, nodes.Name):
14            func_name = node.func.name
15        else:
16            # Not interested in other nodes.
17            return
18
19        qnames = {inferred.qname(), func_name}
20        if any(name in self.deprecated_methods() for name in qnames):
21            self.add_message("deprecated-method", node=node, args=(func_name,))
22            return
23        num_of_args = len(node.args)
24        kwargs = {kw.arg for kw in node.keywords} if node.keywords else {}
25        deprecated_arguments = (self.deprecated_arguments(qn) for qn in qnames)
26        for position, arg_name in chain(*deprecated_arguments):
27            if arg_name in kwargs:
28                # function was called with deprecated argument as keyword argument
29                self.add_message(
30                    "deprecated-argument", node=node, args=(arg_name, func_name)
31                )
32            elif position is not None and position < num_of_args:
33                # function was called with deprecated argument as positional argument
34                self.add_message(
35                    "deprecated-argument", node=node, args=(arg_name, func_name)
36                )