Path 1: 1121 calls (0.86)

→ node Module (1121)

→ walker ASTWalker (1121)

→ rawcheckers list (1121)

→ tokencheckers list (1121)

↩ return True (1121)

11 run 5 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True
            

Path 2: 151 calls (0.12)

→ node Module (151)

→ walker ASTWalker (151)

→ rawcheckers list (151)

→ tokencheckers [] (151)

↩ return True (151)

10 run 6 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True
            

Path 3: 28 calls (0.02)

→ node Module (28)

→ walker ASTWalker (28)

→ rawcheckers [] (28)

→ tokencheckers [] (28)

↩ return True (28)

9 run 7 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True
            

Path 4: 4 calls (0.0)

→ node Module (4)

→ walker ASTWalker (4)

→ rawcheckers list (4)

→ tokencheckers list (4)

↩ return False (4)

6 run 10 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True
            

Path 5: 1 calls (0.0)

→ node Module (1)

→ walker ASTWalker (1)

→ rawcheckers [] (1)

→ tokencheckers list (1)

↩ return True (1)

10 run 6 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True
            

Path 6: 1 calls (0.0)

→ node Module (1)

→ walker ASTWalker (1)

→ rawcheckers list (1)

→ tokencheckers list (1)

↩ return None (1)

⚠ exception TokenError (1)

5 run 11 not run

1def _check_astroid_module(
2        self,
3        node: nodes.Module,
4        walker: ASTWalker,
5        rawcheckers: list[checkers.BaseRawFileChecker],
6        tokencheckers: list[checkers.BaseTokenChecker],
7    ) -> bool | None:
8        """Check given AST node with given walker and checkers.
9
10        :param astroid.nodes.Module node: AST node of the module to check
11        :param pylint.utils.ast_walker.ASTWalker walker: AST walker
12        :param list rawcheckers: List of token checkers to use
13        :param list tokencheckers: List of raw checkers to use
14
15        :returns: True if the module was checked, False if ignored,
16            None if the module contents could not be parsed
17        """
18        try:
19            tokens = utils.tokenize_module(node)
20        except tokenize.TokenError as ex:
21            self.add_message("syntax-error", line=ex.args[1][0], args=ex.args[0])
22            return None
23
24        if not node.pure_python:
25            self.add_message("raw-checker-failed", args=node.name)
26        else:
27            # assert astroid.file.endswith('.py')
28            # Parse module/block level option pragma's
29            self.process_tokens(tokens)
30            if self._ignore_file:
31                return False
32            # run raw and tokens checkers
33            for raw_checker in rawcheckers:
34                raw_checker.process_module(node)
35            for token_checker in tokencheckers:
36                token_checker.process_tokens(tokens)
37        # generate events to astroid checkers
38        walker.walk(node)
39        return True