Path 1: 35 calls (0.47)

↩ return tuple (35)

6 run 19 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 2: 13 calls (0.17)

↩ return tuple (13)

20 run 5 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 3: 11 calls (0.15)

↩ return tuple (11)

19 run 6 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 4: 4 calls (0.05)

↩ return tuple (4)

17 run 8 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 5: 3 calls (0.04)

↩ return tuple (3)

20 run 5 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 6: 2 calls (0.03)

↩ return tuple (2)

23 run 2 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 7: 2 calls (0.03)

↩ return tuple (2)

9 run 16 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 8: 1 calls (0.01)

↩ return tuple (1)

21 run 4 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 9: 1 calls (0.01)

↩ return tuple (1)

18 run 7 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 10: 1 calls (0.01)

↩ return tuple (1)

23 run 2 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 11: 1 calls (0.01)

↩ return tuple (1)

16 run 9 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type
            

Path 12: 1 calls (0.01)

↩ return tuple (1)

21 run 4 not run

1def match_param_docs(self) -> tuple[set[str], set[str]]:
2        """Matches parameter documentation section to parameter documentation rules."""
3        params_with_doc = set()
4        params_with_type = set()
5
6        entries = self._parse_section(self.re_param_section)
7        entries.extend(self._parse_section(self.re_keyword_param_section))
8        for entry in entries:
9            match = self.re_param_line.match(entry)
10            if not match:
11                continue
12
13            # check if parameter has description only
14            re_only_desc = re.match(r"\s*(\*{0,2}\w+)\s*:?\n\s*\w*$", entry)
15            if re_only_desc:
16                param_name = match.group("param_name")
17                param_desc = match.group("param_type")
18                param_type = None
19            else:
20                param_name = match.group("param_name")
21                param_type = match.group("param_type")
22                param_desc = match.group("param_desc")
23                # The re_param_line pattern needs to match multi-line which removes the ability
24                # to match a single line description like 'arg : a number type.'
25                # We are not trying to determine whether 'a number type' is correct typing
26                # but we do accept it as typing as it is in the place where typing
27                # should be
28                if param_type is None and re.match(r"\s*(\*{0,2}\w+)\s*:.+$", entry):
29                    param_type = param_desc
30                # If the description is "" but we have a type description
31                # we consider the description to be the type
32                if not param_desc and param_type:
33                    param_desc = param_type
34
35            if param_type:
36                params_with_type.add(param_name)
37
38            if param_desc:
39                params_with_doc.add(param_name)
40
41        return params_with_doc, params_with_type