Path 1: 115 calls (0.38)

→ doc GoogleDocstring (39) SphinxDocstring (37) NumpyDocstring (34) Docstring (5)

→ arguments_node Arguments (115)

→ warning_node FunctionDef (115)

→ accept_no_param_doc None (115)

45 run 37 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 2: 69 calls (0.23)

→ doc SphinxDocstring (28) NumpyDocstring (25) GoogleDocstring (16)

→ arguments_node Arguments (69)

→ warning_node FunctionDef (65) ClassDef (4)

→ accept_no_param_doc None (69)

63 run 19 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 3: 22 calls (0.07)

→ doc Docstring (22)

→ arguments_node Arguments (22)

→ warning_node FunctionDef (17) ClassDef (5)

→ accept_no_param_doc None (15) True (7)

↩ return None (22)

2 run 80 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 4: 18 calls (0.06)

→ doc GoogleDocstring (10) SphinxDocstring (6) Docstring (2)

→ arguments_node Arguments (18)

→ warning_node FunctionDef (18)

→ accept_no_param_doc None (18)

64 run 18 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 5: 14 calls (0.05)

→ doc Docstring (11) NumpyDocstring (3)

→ arguments_node Arguments (14)

→ warning_node FunctionDef (10) AsyncFunctionDef (4)

→ accept_no_param_doc None (14)

56 run 26 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 6: 12 calls (0.04)

→ doc GoogleDocstring (7) SphinxDocstring (5)

→ arguments_node Arguments (12)

→ warning_node FunctionDef (12)

→ accept_no_param_doc None (12)

44 run 38 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 7: 11 calls (0.04)

→ doc GoogleDocstring (4) SphinxDocstring (4) NumpyDocstring (3)

→ arguments_node Arguments (11)

→ warning_node FunctionDef (11)

→ accept_no_param_doc None (11)

65 run 17 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 8: 9 calls (0.03)

→ doc SphinxDocstring (4) NumpyDocstring (3) GoogleDocstring (2)

→ arguments_node Arguments (9)

→ warning_node FunctionDef (9)

→ accept_no_param_doc None (9)

65 run 17 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 9: 8 calls (0.03)

→ doc Docstring (2) GoogleDocstring (2) NumpyDocstring (2) SphinxDocstring (2)

→ arguments_node Arguments (8)

→ warning_node FunctionDef (7) ClassDef (1)

→ accept_no_param_doc None (8)

44 run 38 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 10: 6 calls (0.02)

→ doc GoogleDocstring (2) NumpyDocstring (2) SphinxDocstring (2)

→ arguments_node Arguments (6)

→ warning_node ClassDef (3) FunctionDef (3)

→ accept_no_param_doc True (6)

62 run 20 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 11: 3 calls (0.01)

→ doc Docstring (3)

→ arguments_node Arguments (3)

→ warning_node FunctionDef (2) ClassDef (1)

→ accept_no_param_doc True (3)

44 run 38 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 12: 2 calls (0.01)

→ doc SphinxDocstring (1) GoogleDocstring (1)

→ arguments_node Arguments (2)

→ warning_node FunctionDef (2)

→ accept_no_param_doc None (2)

66 run 16 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 13: 2 calls (0.01)

→ doc GoogleDocstring (1) NumpyDocstring (1)

→ arguments_node Arguments (2)

→ warning_node FunctionDef (2)

→ accept_no_param_doc None (2)

66 run 16 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 14: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

64 run 18 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 15: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

63 run 19 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 16: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

64 run 18 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 17: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

63 run 19 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 18: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

68 run 14 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 19: 1 calls (0.0)

→ doc NumpyDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

66 run 16 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 20: 1 calls (0.0)

→ doc NumpyDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

64 run 18 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 21: 1 calls (0.0)

→ doc SphinxDocstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

64 run 18 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 22: 1 calls (0.0)

→ doc Docstring (1)

→ arguments_node Arguments (1)

→ warning_node ClassDef (1)

→ accept_no_param_doc True (1)

45 run 37 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )
            

Path 23: 1 calls (0.0)

→ doc Docstring (1)

→ arguments_node Arguments (1)

→ warning_node FunctionDef (1)

→ accept_no_param_doc None (1)

46 run 36 not run

1def check_arguments_in_docstring(
2        self,
3        doc: Docstring,
4        arguments_node: astroid.Arguments,
5        warning_node: astroid.NodeNG,
6        accept_no_param_doc: bool | None = None,
7    ) -> None:
8        """Check that all parameters are consistent with the parameters mentioned
9        in the parameter documentation (e.g. the Sphinx tags 'param' and 'type').
10
11        * Undocumented parameters except 'self' are noticed.
12        * Undocumented parameter types except for 'self' and the ``*<args>``
13          and ``**<kwargs>`` parameters are noticed.
14        * Parameters mentioned in the parameter documentation that don't or no
15          longer exist in the function parameter list are noticed.
16        * If the text "For the parameters, see" or "For the other parameters,
17          see" (ignoring additional white-space) is mentioned in the docstring,
18          missing parameter documentation is tolerated.
19        * If there's no Sphinx style, Google style or NumPy style parameter
20          documentation at all, i.e. ``:param`` is never mentioned etc., the
21          checker assumes that the parameters are documented in another format
22          and the absence is tolerated.
23
24        :param doc: Docstring for the function, method or class.
25        :type doc: :class:`Docstring`
26
27        :param arguments_node: Arguments node for the function, method or
28            class constructor.
29        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
30
31        :param warning_node: The node to assign the warnings to
32        :type warning_node: :class:`astroid.scoped_nodes.Node`
33
34        :param accept_no_param_doc: Whether to allow no parameters to be
35            documented. If None then this value is read from the configuration.
36        :type accept_no_param_doc: bool or None
37        """
38        # Tolerate missing param or type declarations if there is a link to
39        # another method carrying the same name.
40        if not doc.doc:
41            return
42
43        if accept_no_param_doc is None:
44            accept_no_param_doc = self.linter.config.accept_no_param_doc
45        tolerate_missing_params = doc.params_documented_elsewhere()
46
47        # Collect the function arguments.
48        expected_argument_names = {arg.name for arg in arguments_node.args}
49        expected_argument_names.update(arg.name for arg in arguments_node.kwonlyargs)
50        expected_argument_names.update(arg.name for arg in arguments_node.posonlyargs)
51        not_needed_type_in_docstring = self.not_needed_param_in_docstring.copy()
52
53        expected_but_ignored_argument_names = set()
54        ignored_argument_names = self.linter.config.ignored_argument_names
55        if ignored_argument_names:
56            expected_but_ignored_argument_names = {
57                arg
58                for arg in expected_argument_names
59                if ignored_argument_names.match(arg)
60            }
61
62        if arguments_node.vararg is not None:
63            expected_argument_names.add(f"*{arguments_node.vararg}")
64            not_needed_type_in_docstring.add(f"*{arguments_node.vararg}")
65        if arguments_node.kwarg is not None:
66            expected_argument_names.add(f"**{arguments_node.kwarg}")
67            not_needed_type_in_docstring.add(f"**{arguments_node.kwarg}")
68        params_with_doc, params_with_type = doc.match_param_docs()
69        # Tolerate no parameter documentation at all.
70        if not params_with_doc and not params_with_type and accept_no_param_doc:
71            tolerate_missing_params = True
72
73        # This is before the update of param_with_type because this must check only
74        # the type documented in a docstring, not the one using pep484
75        # See #4117 and #4593
76        self._compare_ignored_args(
77            params_with_type,
78            "useless-type-doc",
79            expected_but_ignored_argument_names,
80            warning_node,
81        )
82        for index, arg_name in enumerate(arguments_node.args):
83            if arguments_node.annotations[index]:
84                params_with_type.add(arg_name.name)
85        for index, arg_name in enumerate(arguments_node.kwonlyargs):
86            if arguments_node.kwonlyargs_annotations[index]:
87                params_with_type.add(arg_name.name)
88        for index, arg_name in enumerate(arguments_node.posonlyargs):
89            if arguments_node.posonlyargs_annotations[index]:
90                params_with_type.add(arg_name.name)
91
92        if not tolerate_missing_params:
93            missing_param_doc = (expected_argument_names - params_with_doc) - (
94                self.not_needed_param_in_docstring | expected_but_ignored_argument_names
95            )
96            missing_type_doc = (expected_argument_names - params_with_type) - (
97                not_needed_type_in_docstring | expected_but_ignored_argument_names
98            )
99            if (
100                missing_param_doc == expected_argument_names == missing_type_doc
101                and len(expected_argument_names) != 0
102            ):
103                self.add_message(
104                    "missing-any-param-doc",
105                    args=(warning_node.name,),
106                    node=warning_node,
107                    confidence=HIGH,
108                )
109            else:
110                self._compare_missing_args(
111                    params_with_doc,
112                    "missing-param-doc",
113                    self.not_needed_param_in_docstring
114                    | expected_but_ignored_argument_names,
115                    expected_argument_names,
116                    warning_node,
117                )
118                self._compare_missing_args(
119                    params_with_type,
120                    "missing-type-doc",
121                    not_needed_type_in_docstring | expected_but_ignored_argument_names,
122                    expected_argument_names,
123                    warning_node,
124                )
125
126        self._compare_different_args(
127            params_with_doc,
128            "differing-param-doc",
129            self.not_needed_param_in_docstring,
130            expected_argument_names,
131            warning_node,
132        )
133        self._compare_different_args(
134            params_with_type,
135            "differing-type-doc",
136            not_needed_type_in_docstring,
137            expected_argument_names,
138            warning_node,
139        )
140        self._compare_ignored_args(
141            params_with_doc,
142            "useless-param-doc",
143            expected_but_ignored_argument_names,
144            warning_node,
145        )