Path 1: 2146 calls (0.61)

FunctionDef (2118) AsyncFunctionDef (28) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 2: 1019 calls (0.29)

FunctionDef (994) AsyncFunctionDef (25) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 3: 315 calls (0.09)

FunctionDef (315) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 4: 23 calls (0.01)

FunctionDef (23) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 5: 8 calls (0.0)

FunctionDef (8) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 6: 6 calls (0.0)

FunctionDef (5) AsyncFunctionDef (1) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 7: 2 calls (0.0)

FunctionDef (2)

GeneratorExit (2) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 8: 1 calls (0.0)

FunctionDef (1) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg

Path 9: 1 calls (0.0)

FunctionDef (1) 

1@utils.only_required_for_messages(
2        "init-is-generator",
3        "return-in-init",
4        "function-redefined",
5        "return-arg-in-generator",
6        "duplicate-argument-name",
7        "nonlocal-and-global",
8        "used-prior-global-declaration",
9    )
10    def visit_functiondef(self, node: nodes.FunctionDef) -> None:
11        self._check_nonlocal_and_global(node)
12        self._check_name_used_prior_global(node)
13        if not redefined_by_decorator(
14            node
15        ) and not utils.is_registered_in_singledispatch_function(node):
16            self._check_redefinition(node.is_method() and "method" or "function", node)
17        # checks for max returns, branch, return in __init__
18        returns = node.nodes_of_class(
19            nodes.Return, skip_klass=(nodes.FunctionDef, nodes.ClassDef)
20        )
21        if node.is_method() and node.name == "__init__":
22            if node.is_generator():
23                self.add_message("init-is-generator", node=node)
24            else:
25                values = [r.value for r in returns]
26                # Are we returning anything but None from constructors
27                if any(v for v in values if not utils.is_none(v)):
28                    self.add_message("return-in-init", node=node)
29        # Check for duplicate names by clustering args with same name for detailed report
30        arg_clusters = {}
31        arguments: Iterator[Any] = filter(None, [node.args.args, node.args.kwonlyargs])
32        for arg in itertools.chain.from_iterable(arguments):
33            if arg.name in arg_clusters:
34                self.add_message(
35                    "duplicate-argument-name",
36                    node=arg,
37                    args=(arg.name,),
38                    confidence=HIGH,
39                )
40            else:
41                arg_clusters[arg.name] = arg