Path 1: 2455 calls (0.47)

→ node_type 'function' (862) 'module' (686) 'class' (570) 'method' (337)

→ node FunctionDef (1190) Module (686) ClassDef (570) AsyncFunctionDef (9)

→ report_missing True (2424) False (31)

→ confidence Confidence (2455)

4 run 32 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 2: 1062 calls (0.2)

→ node_type 'function' (635) 'method' (427)

→ node FunctionDef (1036) AsyncFunctionDef (26)

→ report_missing True (1062)

→ confidence Confidence (1062)

18 run 18 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 3: 924 calls (0.18)

→ node_type 'class' (924)

→ node ClassDef (924)

→ report_missing True (924)

→ confidence Confidence (924)

18 run 18 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 4: 288 calls (0.06)

→ node_type 'module' (288)

→ node Module (288)

→ report_missing True (288)

→ confidence Confidence (288)

17 run 19 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 5: 125 calls (0.02)

→ node_type 'module' (125)

→ node Module (125)

→ report_missing True (125)

→ confidence Confidence (125)

↩ return None (125)

8 run 28 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 6: 105 calls (0.02)

→ node_type 'function' (63) 'method' (42)

→ node FunctionDef (103) AsyncFunctionDef (2)

→ report_missing True (105)

→ confidence Confidence (105)

21 run 15 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 7: 103 calls (0.02)

→ node_type 'method' (103)

→ node FunctionDef (100) AsyncFunctionDef (3)

→ report_missing False (103)

→ confidence Confidence (103)

↩ return None (103)

6 run 30 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 8: 82 calls (0.02)

→ node_type 'function' (56) 'method' (26)

→ node FunctionDef (74) AsyncFunctionDef (8)

→ report_missing True (82)

→ confidence Confidence (82)

19 run 17 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 9: 17 calls (0.0)

→ node_type 'class' (17)

→ node ClassDef (17)

→ report_missing True (17)

→ confidence Confidence (17)

19 run 17 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 10: 10 calls (0.0)

→ node_type 'method' (9) 'function' (1)

→ node FunctionDef (10)

→ report_missing True (10)

→ confidence Confidence (10)

23 run 13 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 11: 6 calls (0.0)

→ node_type 'function' (3) 'method' (2) 'module' (1)

→ node FunctionDef (4) AsyncFunctionDef (1) Module (1)

→ report_missing True (5) False (1)

→ confidence Confidence (6)

8 run 28 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 12: 5 calls (0.0)

→ node_type 'module' (5)

→ node Module (5)

→ report_missing True (5)

→ confidence Confidence (5)

18 run 18 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 13: 4 calls (0.0)

→ node_type 'module' (4)

→ node Module (4)

→ report_missing True (4)

→ confidence Confidence (4)

20 run 16 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 14: 2 calls (0.0)

→ node_type 'function' (2)

→ node FunctionDef (2)

→ report_missing True (2)

→ confidence Confidence (2)

↩ return None (2)

20 run 16 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 15: 2 calls (0.0)

→ node_type 'method' (2)

→ node FunctionDef (2)

→ report_missing True (2)

→ confidence Confidence (2)

22 run 14 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 16: 1 calls (0.0)

→ node_type 'class' (1)

→ node ClassDef (1)

→ report_missing True (1)

→ confidence Confidence (1)

5 run 31 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )
            

Path 17: 1 calls (0.0)

→ node_type 'function' (1)

→ node FunctionDef (1)

→ report_missing True (1)

→ confidence Confidence (1)

↩ return None (1)

10 run 26 not run

1def _check_docstring(
2        self,
3        node_type: Literal["class", "function", "method", "module"],
4        node: nodes.Module | nodes.ClassDef | nodes.FunctionDef,
5        report_missing: bool = True,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7    ) -> None:
8        """Check if the node has a non-empty docstring."""
9        docstring = node.doc_node.value if node.doc_node else None
10        if docstring is None:
11            docstring = _infer_dunder_doc_attribute(node)
12
13        if docstring is None:
14            if not report_missing:
15                return
16            lines = utils.get_node_last_lineno(node) - node.lineno
17
18            if node_type == "module" and not lines:
19                # If the module does not have a body, there's no reason
20                # to require a docstring.
21                return
22            max_lines = self.linter.config.docstring_min_length
23
24            if node_type != "module" and max_lines > -1 and lines < max_lines:
25                return
26            if node_type == "class":
27                self.linter.stats.undocumented["klass"] += 1
28            else:
29                self.linter.stats.undocumented[node_type] += 1
30            if (
31                node.body
32                and isinstance(node.body[0], nodes.Expr)
33                and isinstance(node.body[0].value, nodes.Call)
34            ):
35                # Most likely a string with a format call. Let's see.
36                func = utils.safe_infer(node.body[0].value.func)
37                if isinstance(func, astroid.BoundMethod) and isinstance(
38                    func.bound, astroid.Instance
39                ):
40                    # Strings.
41                    if func.bound.name in {"str", "unicode", "bytes"}:
42                        return
43            if node_type == "module":
44                message = "missing-module-docstring"
45            elif node_type == "class":
46                message = "missing-class-docstring"
47            else:
48                message = "missing-function-docstring"
49            self.add_message(message, node=node, confidence=confidence)
50        elif not docstring.strip():
51            if node_type == "class":
52                self.linter.stats.undocumented["klass"] += 1
53            else:
54                self.linter.stats.undocumented[node_type] += 1
55            self.add_message(
56                "empty-docstring", node=node, args=(node_type,), confidence=confidence
57            )