Path 1: 304 calls (0.54)

→ found_argument_names set() (303) {'*args'} (1)

→ message_id 'differing-type-doc' (158) 'differing-param-doc' (146)

→ not_needed_names {'self', 'cls'} (303) {'self', 'cls', '*args'} (1)

→ expected_argument_names {'self'} (232) {'self', 'x', 'y'} (23) {'param1'} (16) {'arg1', 'arg2'} (8) {'x', 'y'} (6) {'self', 'value'} (6) {'par1'} (3) {'self', 'my_param'} (3)...

→ warning_node FunctionDef (285) ClassDef (11) AsyncFunctionDef (8)

9 run 6 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 2: 129 calls (0.23)

→ found_argument_names {'named_arg'} (27) {'doc_type'} (20) {'y'} (12) {'arg'} (12) {'yarg'} (6) {'my_param'} (5) {'arg1'} (4) {'**kwargs', 'named_arg'} (4) {'arg1', 'arg3'}...

→ message_id 'differing-param-doc' (68) 'differing-type-doc' (61)

→ not_needed_names {'self', 'cls'} (106) {'self', 'cls', '*args'} (12) {'self', 'cls', '**kwargs'} (11)

→ expected_argument_names {'self', 'doc_type'} (20) {'**kwargs', 'named_arg'} (19) {'self', 'x', 'y'} (15) {'*args', 'named_arg'} (15) {'arg1', 'arg3', 'arg2'} (7) {'x', 'y', '...

→ warning_node FunctionDef (120) ClassDef (9)

10 run 5 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 3: 84 calls (0.15)

→ found_argument_names {'named_arg'} (20) {'par1'} (6) {'x', 'y', 'z'} (5) {'zarg', 'warg', 'yarg', 'xarg'} (5) {'_some_private_param', 'public_param'} (4) {'_new'} (4) {'bo...

→ message_id 'differing-param-doc' (43) 'differing-type-doc' (41)

→ not_needed_names {'self', 'cls'} (84)

→ expected_argument_names {'named_arg'} (20) {'par1'} (6) {'zarg', 'warg', 'yarg', 'xarg'} (6) {'x', 'y', 'z'} (5) {'_some_private_param', 'public_param'} (4) {'_new'} (4) {'bo...

→ warning_node FunctionDef (84)

9 run 6 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 4: 24 calls (0.04)

→ found_argument_names set() (24)

→ message_id 'differing-param-doc' (12) 'differing-type-doc' (12)

→ not_needed_names {'self', 'cls'} (24)

→ expected_argument_names set() (24)

→ warning_node FunctionDef (24)

7 run 8 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 5: 8 calls (0.01)

→ found_argument_names {'xarg1', 'yarg', 'zarg1'} (5) {'this', 'these', 'other'} (2) {'zarg1', 'xarg', 'yarg1'} (1)

→ message_id 'differing-param-doc' (4) 'differing-type-doc' (4)

→ not_needed_names {'self', 'cls'} (8)

→ expected_argument_names {'zarg', 'yarg', 'xarg'} (6) {'this', 'that', 'other'} (2)

→ warning_node FunctionDef (8)

15 run 0 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 6: 6 calls (0.01)

→ found_argument_names {'yarg1'} (6)

→ message_id 'differing-param-doc' (3) 'differing-type-doc' (3)

→ not_needed_names {'self', 'cls'} (6)

→ expected_argument_names {'yarg', 'xarg'} (4) {'zarg', 'yarg', 'xarg'} (2)

→ warning_node FunctionDef (6)

14 run 1 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )
            

Path 7: 3 calls (0.01)

→ found_argument_names {'param', 'par1'} (3)

→ message_id 'differing-param-doc' (3)

→ not_needed_names {'self', 'cls'} (3)

→ expected_argument_names {'par1'} (3)

→ warning_node FunctionDef (3)

14 run 1 not run

1def _compare_different_args(
2        self,
3        found_argument_names: set[str],
4        message_id: str,
5        not_needed_names: set[str],
6        expected_argument_names: set[str],
7        warning_node: nodes.NodeNG,
8    ) -> None:
9        """Compare the found argument names with the expected ones and
10        generate a message if there are extra arguments found.
11
12        :param found_argument_names: argument names found in the docstring
13
14        :param message_id: pylint message id
15
16        :param not_needed_names: names that may be omitted
17
18        :param expected_argument_names: Expected argument names
19
20        :param warning_node: The node to be analyzed
21        """
22        # Handle variadic and keyword args without asterisks
23        modified_expected_argument_names: set[str] = set()
24        for name in expected_argument_names:
25            if name.replace("*", "") in found_argument_names:
26                modified_expected_argument_names.add(name.replace("*", ""))
27            else:
28                modified_expected_argument_names.add(name)
29
30        differing_argument_names = (
31            (modified_expected_argument_names ^ found_argument_names)
32            - not_needed_names
33            - expected_argument_names
34        )
35
36        if differing_argument_names:
37            self.add_message(
38                message_id,
39                args=(", ".join(sorted(differing_argument_names)),),
40                node=warning_node,
41                confidence=HIGH,
42            )