Path 1: 2426 calls (0.43)

→ node Call (2426)

↩ return None (2426)

6 run 10 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 2: 2415 calls (0.42)

→ node Call (2415)

↩ return None (2415)

5 run 11 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 3: 833 calls (0.15)

→ node Call (833)

↩ return None (833)

7 run 9 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 4: 13 calls (0.0)

→ node Call (13)

↩ return None (13)

9 run 7 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 5: 9 calls (0.0)

→ node Call (9)

↩ return None (9)

6 run 10 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 6: 8 calls (0.0)

→ node Call (8)

↩ return None (8)

10 run 6 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )
            

Path 7: 4 calls (0.0)

→ node Call (4)

14 run 2 not run

1def _check_positional_only_arguments_expected(self, node: nodes.Call) -> None:
2        """Check if positional only arguments have been passed as keyword arguments by
3        inspecting its method definition.
4        """
5        inferred_func = utils.safe_infer(node.func)
6        while isinstance(inferred_func, (astroid.BoundMethod, astroid.UnboundMethod)):
7            inferred_func = inferred_func._proxied
8        if not (
9            isinstance(inferred_func, (nodes.FunctionDef))
10            and inferred_func.args.posonlyargs
11        ):
12            return
13        pos_args = [a.name for a in inferred_func.args.posonlyargs]
14        kws = [k.arg for k in node.keywords if k.arg in pos_args]
15        if not kws:
16            return
17
18        self.add_message(
19            "positional-only-arguments-expected",
20            node=node,
21            args=(node.func.as_string(), ", ".join(f"'{k}'" for k in kws)),
22            confidence=INFERENCE,
23        )