Path 1: 254 calls (0.81)

→ node TryExcept (254)

8 run 30 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)
            

Path 2: 28 calls (0.09)

→ node TryExcept (28)

9 run 29 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)
            

Path 3: 22 calls (0.07)

→ node TryExcept (22)

13 run 25 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)
            

Path 4: 6 calls (0.02)

→ node TryExcept (6)

⚠ exception GeneratorExit (6)

21 run 17 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)
            

Path 5: 3 calls (0.01)

→ node TryExcept (3)

20 run 18 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)
            

Path 6: 1 calls (0.0)

→ node TryExcept (1)

14 run 24 not run

1def _check_try_except_raise(self, node: nodes.TryExcept) -> None:
2        def gather_exceptions_from_handler(
3            handler: nodes.ExceptHandler,
4        ) -> list[InferenceResult] | None:
5            exceptions: list[InferenceResult] = []
6            if handler.type:
7                exceptions_in_handler = utils.safe_infer(handler.type)
8                if isinstance(exceptions_in_handler, nodes.Tuple):
9                    exceptions = list(
10                        {
11                            exception
12                            for exception in exceptions_in_handler.elts
13                            if isinstance(exception, (nodes.Name, nodes.Attribute))
14                        }
15                    )
16                elif exceptions_in_handler:
17                    exceptions = [exceptions_in_handler]
18                else:
19                    # Break when we cannot infer anything reliably.
20                    return None
21            return exceptions
22
23        bare_raise = False
24        handler_having_bare_raise = None
25        exceptions_in_bare_handler: list[InferenceResult] | None = []
26        for handler in node.handlers:
27            if bare_raise:
28                # check that subsequent handler is not parent of handler which had bare raise.
29                # since utils.safe_infer can fail for bare except, check it before.
30                # also break early if bare except is followed by bare except.
31
32                excs_in_current_handler = gather_exceptions_from_handler(handler)
33                if not excs_in_current_handler:
34                    break
35                if exceptions_in_bare_handler is None:
36                    # It can be `None` when the inference failed
37                    break
38                for exc_in_current_handler in excs_in_current_handler:
39                    inferred_current = utils.safe_infer(exc_in_current_handler)
40                    if any(
41                        utils.is_subclass_of(utils.safe_infer(e), inferred_current)
42                        for e in exceptions_in_bare_handler
43                    ):
44                        bare_raise = False
45                        break
46
47            # `raise` as the first operator inside the except handler
48            if _is_raising([handler.body[0]]):
49                # flags when there is a bare raise
50                if handler.body[0].exc is None:
51                    bare_raise = True
52                    handler_having_bare_raise = handler
53                    exceptions_in_bare_handler = gather_exceptions_from_handler(handler)
54        else:
55            if bare_raise:
56                self.add_message("try-except-raise", node=handler_having_bare_raise)