Path 1: 14 calls (0.78)

→ stack Stack (14)

⇇ yield Text (14) '' (14) Syntax (14)

39 run 23 not run

1@group()
2    def _render_stack(self, stack: Stack) -> RenderResult:
3        path_highlighter = PathHighlighter()
4        theme = self.theme
5        code_cache: Dict[str, str] = {}
6
7        def read_code(filename: str) -> str:
8            """Read files, and cache results on filename.
9
10            Args:
11                filename (str): Filename to read
12
13            Returns:
14                str: Contents of file
15            """
16            code = code_cache.get(filename)
17            if code is None:
18                with open(
19                    filename, "rt", encoding="utf-8", errors="replace"
20                ) as code_file:
21                    code = code_file.read()
22                code_cache[filename] = code
23            return code
24
25        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
26            if frame.locals:
27                yield render_scope(
28                    frame.locals,
29                    title="locals",
30                    indent_guides=self.indent_guides,
31                    max_length=self.locals_max_length,
32                    max_string=self.locals_max_string,
33                )
34
35        exclude_frames: Optional[range] = None
36        if self.max_frames != 0:
37            exclude_frames = range(
38                self.max_frames // 2,
39                len(stack.frames) - self.max_frames // 2,
40            )
41
42        excluded = False
43        for frame_index, frame in enumerate(stack.frames):
44
45            if exclude_frames and frame_index in exclude_frames:
46                excluded = True
47                continue
48
49            if excluded:
50                assert exclude_frames is not None
51                yield Text(
52                    f"\n... {len(exclude_frames)} frames hidden ...",
53                    justify="center",
54                    style="traceback.error",
55                )
56                excluded = False
57
58            first = frame_index == 0
59            frame_filename = frame.filename
60            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
61
62            text = Text.assemble(
63                path_highlighter(Text(frame.filename, style="pygments.string")),
64                (":", "pygments.text"),
65                (str(frame.lineno), "pygments.number"),
66                " in ",
67                (frame.name, "pygments.function"),
68                style="pygments.text",
69            )
70            if not frame.filename.startswith("<") and not first:
71                yield ""
72            yield text
73            if frame.filename.startswith("<"):
74                yield from render_locals(frame)
75                continue
76            if not suppressed:
77                try:
78                    code = read_code(frame.filename)
79                    lexer_name = self._guess_lexer(frame.filename, code)
80                    syntax = Syntax(
81                        code,
82                        lexer_name,
83                        theme=theme,
84                        line_numbers=True,
85                        line_range=(
86                            frame.lineno - self.extra_lines,
87                            frame.lineno + self.extra_lines,
88                        ),
89                        highlight_lines={frame.lineno},
90                        word_wrap=self.word_wrap,
91                        code_width=88,
92                        indent_guides=self.indent_guides,
93                        dedent=False,
94                    )
95                    yield ""
96                except Exception as error:
97                    yield Text.assemble(
98                        (f"\n{error}", "traceback.error"),
99                    )
100                else:
101                    yield (
102                        Columns(
103                            [
104                                syntax,
105                                *render_locals(frame),
106                            ],
107                            padding=1,
108                        )
109                        if frame.locals
110                        else syntax
111                    )
            

Path 2: 1 calls (0.06)

→ stack Stack (1)

⇇ yield '' (5) Text (3) Syntax (3)

40 run 23 not run

1@group()
2    def _render_stack(self, stack: Stack) -> RenderResult:
3        path_highlighter = PathHighlighter()
4        theme = self.theme
5        code_cache: Dict[str, str] = {}
6
7        def read_code(filename: str) -> str:
8            """Read files, and cache results on filename.
9
10            Args:
11                filename (str): Filename to read
12
13            Returns:
14                str: Contents of file
15            """
16            code = code_cache.get(filename)
17            if code is None:
18                with open(
19                    filename, "rt", encoding="utf-8", errors="replace"
20                ) as code_file:
21                    code = code_file.read()
22                code_cache[filename] = code
23            return code
24
25        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
26            if frame.locals:
27                yield render_scope(
28                    frame.locals,
29                    title="locals",
30                    indent_guides=self.indent_guides,
31                    max_length=self.locals_max_length,
32                    max_string=self.locals_max_string,
33                )
34
35        exclude_frames: Optional[range] = None
36        if self.max_frames != 0:
37            exclude_frames = range(
38                self.max_frames // 2,
39                len(stack.frames) - self.max_frames // 2,
40            )
41
42        excluded = False
43        for frame_index, frame in enumerate(stack.frames):
44
45            if exclude_frames and frame_index in exclude_frames:
46                excluded = True
47                continue
48
49            if excluded:
50                assert exclude_frames is not None
51                yield Text(
52                    f"\n... {len(exclude_frames)} frames hidden ...",
53                    justify="center",
54                    style="traceback.error",
55                )
56                excluded = False
57
58            first = frame_index == 0
59            frame_filename = frame.filename
60            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
61
62            text = Text.assemble(
63                path_highlighter(Text(frame.filename, style="pygments.string")),
64                (":", "pygments.text"),
65                (str(frame.lineno), "pygments.number"),
66                " in ",
67                (frame.name, "pygments.function"),
68                style="pygments.text",
69            )
70            if not frame.filename.startswith("<") and not first:
71                yield ""
72            yield text
73            if frame.filename.startswith("<"):
74                yield from render_locals(frame)
75                continue
76            if not suppressed:
77                try:
78                    code = read_code(frame.filename)
79                    lexer_name = self._guess_lexer(frame.filename, code)
80                    syntax = Syntax(
81                        code,
82                        lexer_name,
83                        theme=theme,
84                        line_numbers=True,
85                        line_range=(
86                            frame.lineno - self.extra_lines,
87                            frame.lineno + self.extra_lines,
88                        ),
89                        highlight_lines={frame.lineno},
90                        word_wrap=self.word_wrap,
91                        code_width=88,
92                        indent_guides=self.indent_guides,
93                        dedent=False,
94                    )
95                    yield ""
96                except Exception as error:
97                    yield Text.assemble(
98                        (f"\n{error}", "traceback.error"),
99                    )
100                else:
101                    yield (
102                        Columns(
103                            [
104                                syntax,
105                                *render_locals(frame),
106                            ],
107                            padding=1,
108                        )
109                        if frame.locals
110                        else syntax
111                    )
            

Path 3: 1 calls (0.06)

→ stack Stack (1)

⇇ yield Text (1) '' (1) Columns (1)

39 run 23 not run

1@group()
2    def _render_stack(self, stack: Stack) -> RenderResult:
3        path_highlighter = PathHighlighter()
4        theme = self.theme
5        code_cache: Dict[str, str] = {}
6
7        def read_code(filename: str) -> str:
8            """Read files, and cache results on filename.
9
10            Args:
11                filename (str): Filename to read
12
13            Returns:
14                str: Contents of file
15            """
16            code = code_cache.get(filename)
17            if code is None:
18                with open(
19                    filename, "rt", encoding="utf-8", errors="replace"
20                ) as code_file:
21                    code = code_file.read()
22                code_cache[filename] = code
23            return code
24
25        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
26            if frame.locals:
27                yield render_scope(
28                    frame.locals,
29                    title="locals",
30                    indent_guides=self.indent_guides,
31                    max_length=self.locals_max_length,
32                    max_string=self.locals_max_string,
33                )
34
35        exclude_frames: Optional[range] = None
36        if self.max_frames != 0:
37            exclude_frames = range(
38                self.max_frames // 2,
39                len(stack.frames) - self.max_frames // 2,
40            )
41
42        excluded = False
43        for frame_index, frame in enumerate(stack.frames):
44
45            if exclude_frames and frame_index in exclude_frames:
46                excluded = True
47                continue
48
49            if excluded:
50                assert exclude_frames is not None
51                yield Text(
52                    f"\n... {len(exclude_frames)} frames hidden ...",
53                    justify="center",
54                    style="traceback.error",
55                )
56                excluded = False
57
58            first = frame_index == 0
59            frame_filename = frame.filename
60            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
61
62            text = Text.assemble(
63                path_highlighter(Text(frame.filename, style="pygments.string")),
64                (":", "pygments.text"),
65                (str(frame.lineno), "pygments.number"),
66                " in ",
67                (frame.name, "pygments.function"),
68                style="pygments.text",
69            )
70            if not frame.filename.startswith("<") and not first:
71                yield ""
72            yield text
73            if frame.filename.startswith("<"):
74                yield from render_locals(frame)
75                continue
76            if not suppressed:
77                try:
78                    code = read_code(frame.filename)
79                    lexer_name = self._guess_lexer(frame.filename, code)
80                    syntax = Syntax(
81                        code,
82                        lexer_name,
83                        theme=theme,
84                        line_numbers=True,
85                        line_range=(
86                            frame.lineno - self.extra_lines,
87                            frame.lineno + self.extra_lines,
88                        ),
89                        highlight_lines={frame.lineno},
90                        word_wrap=self.word_wrap,
91                        code_width=88,
92                        indent_guides=self.indent_guides,
93                        dedent=False,
94                    )
95                    yield ""
96                except Exception as error:
97                    yield Text.assemble(
98                        (f"\n{error}", "traceback.error"),
99                    )
100                else:
101                    yield (
102                        Columns(
103                            [
104                                syntax,
105                                *render_locals(frame),
106                            ],
107                            padding=1,
108                        )
109                        if frame.locals
110                        else syntax
111                    )
            

Path 4: 1 calls (0.06)

→ stack Stack (1)

⇇ yield Text (2) '' (1) Syntax (1)

41 run 23 not run

1@group()
2    def _render_stack(self, stack: Stack) -> RenderResult:
3        path_highlighter = PathHighlighter()
4        theme = self.theme
5        code_cache: Dict[str, str] = {}
6
7        def read_code(filename: str) -> str:
8            """Read files, and cache results on filename.
9
10            Args:
11                filename (str): Filename to read
12
13            Returns:
14                str: Contents of file
15            """
16            code = code_cache.get(filename)
17            if code is None:
18                with open(
19                    filename, "rt", encoding="utf-8", errors="replace"
20                ) as code_file:
21                    code = code_file.read()
22                code_cache[filename] = code
23            return code
24
25        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
26            if frame.locals:
27                yield render_scope(
28                    frame.locals,
29                    title="locals",
30                    indent_guides=self.indent_guides,
31                    max_length=self.locals_max_length,
32                    max_string=self.locals_max_string,
33                )
34
35        exclude_frames: Optional[range] = None
36        if self.max_frames != 0:
37            exclude_frames = range(
38                self.max_frames // 2,
39                len(stack.frames) - self.max_frames // 2,
40            )
41
42        excluded = False
43        for frame_index, frame in enumerate(stack.frames):
44
45            if exclude_frames and frame_index in exclude_frames:
46                excluded = True
47                continue
48
49            if excluded:
50                assert exclude_frames is not None
51                yield Text(
52                    f"\n... {len(exclude_frames)} frames hidden ...",
53                    justify="center",
54                    style="traceback.error",
55                )
56                excluded = False
57
58            first = frame_index == 0
59            frame_filename = frame.filename
60            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
61
62            text = Text.assemble(
63                path_highlighter(Text(frame.filename, style="pygments.string")),
64                (":", "pygments.text"),
65                (str(frame.lineno), "pygments.number"),
66                " in ",
67                (frame.name, "pygments.function"),
68                style="pygments.text",
69            )
70            if not frame.filename.startswith("<") and not first:
71                yield ""
72            yield text
73            if frame.filename.startswith("<"):
74                yield from render_locals(frame)
75                continue
76            if not suppressed:
77                try:
78                    code = read_code(frame.filename)
79                    lexer_name = self._guess_lexer(frame.filename, code)
80                    syntax = Syntax(
81                        code,
82                        lexer_name,
83                        theme=theme,
84                        line_numbers=True,
85                        line_range=(
86                            frame.lineno - self.extra_lines,
87                            frame.lineno + self.extra_lines,
88                        ),
89                        highlight_lines={frame.lineno},
90                        word_wrap=self.word_wrap,
91                        code_width=88,
92                        indent_guides=self.indent_guides,
93                        dedent=False,
94                    )
95                    yield ""
96                except Exception as error:
97                    yield Text.assemble(
98                        (f"\n{error}", "traceback.error"),
99                    )
100                else:
101                    yield (
102                        Columns(
103                            [
104                                syntax,
105                                *render_locals(frame),
106                            ],
107                            padding=1,
108                        )
109                        if frame.locals
110                        else syntax
111                    )
            

Path 5: 1 calls (0.06)

→ stack Stack (1)

⇇ yield Text (3) '' (2) Syntax (1)

⚠ exception FileNotFoundError (1)

40 run 23 not run

1@group()
2    def _render_stack(self, stack: Stack) -> RenderResult:
3        path_highlighter = PathHighlighter()
4        theme = self.theme
5        code_cache: Dict[str, str] = {}
6
7        def read_code(filename: str) -> str:
8            """Read files, and cache results on filename.
9
10            Args:
11                filename (str): Filename to read
12
13            Returns:
14                str: Contents of file
15            """
16            code = code_cache.get(filename)
17            if code is None:
18                with open(
19                    filename, "rt", encoding="utf-8", errors="replace"
20                ) as code_file:
21                    code = code_file.read()
22                code_cache[filename] = code
23            return code
24
25        def render_locals(frame: Frame) -> Iterable[ConsoleRenderable]:
26            if frame.locals:
27                yield render_scope(
28                    frame.locals,
29                    title="locals",
30                    indent_guides=self.indent_guides,
31                    max_length=self.locals_max_length,
32                    max_string=self.locals_max_string,
33                )
34
35        exclude_frames: Optional[range] = None
36        if self.max_frames != 0:
37            exclude_frames = range(
38                self.max_frames // 2,
39                len(stack.frames) - self.max_frames // 2,
40            )
41
42        excluded = False
43        for frame_index, frame in enumerate(stack.frames):
44
45            if exclude_frames and frame_index in exclude_frames:
46                excluded = True
47                continue
48
49            if excluded:
50                assert exclude_frames is not None
51                yield Text(
52                    f"\n... {len(exclude_frames)} frames hidden ...",
53                    justify="center",
54                    style="traceback.error",
55                )
56                excluded = False
57
58            first = frame_index == 0
59            frame_filename = frame.filename
60            suppressed = any(frame_filename.startswith(path) for path in self.suppress)
61
62            text = Text.assemble(
63                path_highlighter(Text(frame.filename, style="pygments.string")),
64                (":", "pygments.text"),
65                (str(frame.lineno), "pygments.number"),
66                " in ",
67                (frame.name, "pygments.function"),
68                style="pygments.text",
69            )
70            if not frame.filename.startswith("<") and not first:
71                yield ""
72            yield text
73            if frame.filename.startswith("<"):
74                yield from render_locals(frame)
75                continue
76            if not suppressed:
77                try:
78                    code = read_code(frame.filename)
79                    lexer_name = self._guess_lexer(frame.filename, code)
80                    syntax = Syntax(
81                        code,
82                        lexer_name,
83                        theme=theme,
84                        line_numbers=True,
85                        line_range=(
86                            frame.lineno - self.extra_lines,
87                            frame.lineno + self.extra_lines,
88                        ),
89                        highlight_lines={frame.lineno},
90                        word_wrap=self.word_wrap,
91                        code_width=88,
92                        indent_guides=self.indent_guides,
93                        dedent=False,
94                    )
95                    yield ""
96                except Exception as error:
97                    yield Text.assemble(
98                        (f"\n{error}", "traceback.error"),
99                    )
100                else:
101                    yield (
102                        Columns(
103                            [
104                                syntax,
105                                *render_locals(frame),
106                            ],
107                            padding=1,
108                        )
109                        if frame.locals
110                        else syntax
111                    )