alexmojaki / stack_data / 95

pending completion

Build # 95

Build Type

push

travis-ci-com

Committed by

alexmojaki

Commit Message

Check Source.tree before calling .asttokens()

Run Details

222 of 241 branches covered (92.12%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

8 existing lines in 2 files now uncovered.

529 of 547 relevant lines covered (96.71%)

4.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.13

/stack_data/formatting.py

import inspect
import sys
import traceback
from types import FrameType, TracebackType
from typing import Union, Iterable

from stack_data import style_with_executing_node, Options, Line, FrameInfo, LINE_GAP, Variable, RepeatedFrames
from stack_data.utils import assert_


class Formatter:
    def __init__(
            self, *,
            options=Options(),
            pygmented=False,
            show_executing_node=True,
            pygments_formatter_cls=None,
            pygments_formatter_kwargs=None,
            pygments_style="monokai",
            executing_node_modifier="bg:#005080",
            executing_node_underline="^",
            current_line_indicator="-->",
            line_gap_string="(...)",
            show_variables=False,
            use_code_qualname=True,
            show_linenos=True,
            strip_leading_indent=True,
            html=False,
            chain=True,
            collapse_repeated_frames=True
    ):
        if pygmented and not options.pygments_formatter:
            if show_executing_node:
                pygments_style = style_with_executing_node(
                    pygments_style, executing_node_modifier
                )

            if pygments_formatter_cls is None:
                from pygments.formatters.terminal256 import Terminal256Formatter \
                    as pygments_formatter_cls

            options.pygments_formatter = pygments_formatter_cls(
                style=pygments_style,
                **pygments_formatter_kwargs or {},
            )

        self.pygmented = pygmented
        self.show_executing_node = show_executing_node
        assert_(
            len(executing_node_underline) == 1,
            ValueError("executing_node_underline must be a single character"),
        )
        self.executing_node_underline = executing_node_underline
        self.current_line_indicator = current_line_indicator or ""
        self.line_gap_string = line_gap_string
        self.show_variables = show_variables
        self.show_linenos = show_linenos
        self.use_code_qualname = use_code_qualname
        self.strip_leading_indent = strip_leading_indent
        self.html = html
        self.chain = chain
        self.options = options
        self.collapse_repeated_frames = collapse_repeated_frames

    def set_hook(self):
        def excepthook(_etype, evalue, _tb):
            self.print_exception(evalue)

        sys.excepthook = excepthook

    def print_exception(self, e=None, *, file=None):
        self.print_lines(self.format_exception(e), file=file)

    def print_stack(self, frame_or_tb=None, *, file=None):
        if frame_or_tb is None:
            frame_or_tb = inspect.currentframe().f_back

        self.print_lines(self.format_stack(frame_or_tb), file=file)

    def print_lines(self, lines, *, file=None):
        if file is None:
            file = sys.stderr
        for line in lines:
            print(line, file=file, end="")

    def format_exception(self, e=None) -> Iterable[str]:
        if e is None:
            e = sys.exc_info()[1]

        if self.chain:
            if e.__cause__ is not None:
                yield from self.format_exception(e.__cause__)
                yield traceback._cause_message
            elif (e.__context__ is not None
                  and not e.__suppress_context__):
                yield from self.format_exception(e.__context__)
                yield traceback._context_message

        yield 'Traceback (most recent call last):\n'
        yield from self.format_stack(e.__traceback__)
        yield from traceback.format_exception_only(type(e), e)

    def format_stack(self, frame_or_tb=None) -> Iterable[str]:
        if frame_or_tb is None:
            frame_or_tb = inspect.currentframe().f_back

        yield from self.format_stack_data(
            FrameInfo.stack_data(
                frame_or_tb,
                self.options,
                collapse_repeated_frames=self.collapse_repeated_frames,
            )
        )

    def format_stack_data(
            self, stack: Iterable[Union[FrameInfo, RepeatedFrames]]
    ) -> Iterable[str]:
        for item in stack:
            if isinstance(item, FrameInfo):
                yield from self.format_frame(item)
            else:
                yield self.format_repeated_frames(item)

    def format_repeated_frames(self, repeated_frames: RepeatedFrames) -> str:
        return '    [... skipping similar frames: {}]\n'.format(
            repeated_frames.description
        )

    def format_frame(self, frame: Union[FrameInfo, FrameType, TracebackType]) -> Iterable[str]:
        if not isinstance(frame, FrameInfo):
            frame = FrameInfo(frame, self.options)

        yield self.format_frame_header(frame)

        for line in frame.lines:
            if isinstance(line, Line):
                yield self.format_line(line)
            else:
                assert_(line is LINE_GAP)
                yield self.line_gap_string + "\n"

        if self.show_variables:
            try:
                yield from self.format_variables(frame)
            except Exception:
                pass

    def format_frame_header(self, frame_info: FrameInfo) -> str:
        return ' File "{frame_info.filename}", line {frame_info.lineno}, in {name}\n'.format(
            frame_info=frame_info,
            name=(
                frame_info.executing.code_qualname()
                if self.use_code_qualname else
                frame_info.code.co_name
            ),
        )

    def format_line(self, line: Line) -> str:
        result = ""
        if self.current_line_indicator:
            if line.is_current:
                result = self.current_line_indicator
            else:
                result = " " * len(self.current_line_indicator)
            result += " "

        if self.show_linenos:
            result += "{:4} | ".format(line.lineno)

        result = result or "   "

        prefix = result

        result += line.render(
            pygmented=self.pygmented,
            escape_html=self.html,
            strip_leading_indent=self.strip_leading_indent,
        ) + "\n"

        if self.show_executing_node and not self.pygmented:
            for line_range in line.executing_node_ranges:
                start = line_range.start - line.leading_indent
                end = line_range.end - line.leading_indent
                result += (
                        " " * (start + len(prefix))
                        + self.executing_node_underline * (end - start)
                        + "\n"
                )

        return result

    def format_variables(self, frame_info: FrameInfo) -> Iterable[str]:
        for var in sorted(frame_info.variables, key=lambda v: v.name):
            try:
                yield self.format_variable(var) + "\n"
            except Exception:
                pass

    def format_variable(self, var: Variable) -> str:
        return "{} = {}".format(
            var.name,
            self.format_variable_value(var.value),
        )

    def format_variable_value(self, value) -> str:
        return repr(value)

1	import inspect	5✔
2	import sys	5✔
3	import traceback	5✔
4	from types import FrameType, TracebackType	5✔
5	from typing import Union, Iterable	5✔
6
7	from stack_data import style_with_executing_node, Options, Line, FrameInfo, LINE_GAP, Variable, RepeatedFrames	5✔
8	from stack_data.utils import assert_	5✔
9
10
11	class Formatter:	5✔
12	def __init__(	5✔
13	self, *,
14	options=Options(),
15	pygmented=False,
16	show_executing_node=True,
17	pygments_formatter_cls=None,
18	pygments_formatter_kwargs=None,
19	pygments_style="monokai",
20	executing_node_modifier="bg:#005080",
21	executing_node_underline="^",
22	current_line_indicator="-->",
23	line_gap_string="(...)",
24	show_variables=False,
25	use_code_qualname=True,
26	show_linenos=True,
27	strip_leading_indent=True,
28	html=False,
29	chain=True,
30	collapse_repeated_frames=True
31	):
32	if pygmented and not options.pygments_formatter:	5✔
33	if show_executing_node:	5!
34	pygments_style = style_with_executing_node(	5✔
35	pygments_style, executing_node_modifier
36	)
37
38	if pygments_formatter_cls is None:	5!
39	from pygments.formatters.terminal256 import Terminal256Formatter \	5✔
40	as pygments_formatter_cls
41
42	options.pygments_formatter = pygments_formatter_cls(	5✔
43	style=pygments_style,
44	**pygments_formatter_kwargs or {},
45	)
46
47	self.pygmented = pygmented	5✔
48	self.show_executing_node = show_executing_node	5✔
49	assert_(	5✔
50	len(executing_node_underline) == 1,
51	ValueError("executing_node_underline must be a single character"),
52	)
53	self.executing_node_underline = executing_node_underline	5✔
54	self.current_line_indicator = current_line_indicator or ""	5✔
55	self.line_gap_string = line_gap_string	5✔
56	self.show_variables = show_variables	5✔
57	self.show_linenos = show_linenos	5✔
58	self.use_code_qualname = use_code_qualname	5✔
59	self.strip_leading_indent = strip_leading_indent	5✔
60	self.html = html	5✔
61	self.chain = chain	5✔
62	self.options = options	5✔
63	self.collapse_repeated_frames = collapse_repeated_frames	5✔
64
65	def set_hook(self):	5✔
66	def excepthook(_etype, evalue, _tb):	5✔
67	self.print_exception(evalue)	5✔
68
69	sys.excepthook = excepthook	5✔
70
71	def print_exception(self, e=None, *, file=None):	5✔
72	self.print_lines(self.format_exception(e), file=file)	5✔
73
74	def print_stack(self, frame_or_tb=None, *, file=None):	5✔
75	if frame_or_tb is None:	5!
76	frame_or_tb = inspect.currentframe().f_back	5✔
77
78	self.print_lines(self.format_stack(frame_or_tb), file=file)	5✔
79
80	def print_lines(self, lines, *, file=None):	5✔
81	if file is None:	5!
82	file = sys.stderr	5✔
83	for line in lines:	5✔
84	print(line, file=file, end="")	5✔
85
86	def format_exception(self, e=None) -> Iterable[str]:	5✔
87	if e is None:	5✔
88	e = sys.exc_info()[1]	5✔
89
90	if self.chain:	5!
91	if e.__cause__ is not None:	5✔
92	yield from self.format_exception(e.__cause__)	5✔
93	yield traceback._cause_message	5✔
94	elif (e.__context__ is not None	5✔
95	and not e.__suppress_context__):
96	yield from self.format_exception(e.__context__)	5✔
97	yield traceback._context_message	5✔
98
99	yield 'Traceback (most recent call last):\n'	5✔
100	yield from self.format_stack(e.__traceback__)	5✔
101	yield from traceback.format_exception_only(type(e), e)	5✔
102
103	def format_stack(self, frame_or_tb=None) -> Iterable[str]:	5✔
104	if frame_or_tb is None:	5✔
105	frame_or_tb = inspect.currentframe().f_back	5✔
106
107	yield from self.format_stack_data(	5✔
108	FrameInfo.stack_data(
109	frame_or_tb,
110	self.options,
111	collapse_repeated_frames=self.collapse_repeated_frames,
112	)
113	)
114
115	def format_stack_data(	5✔
116	self, stack: Iterable[Union[FrameInfo, RepeatedFrames]]
117	) -> Iterable[str]:
118	for item in stack:	5✔
119	if isinstance(item, FrameInfo):	5✔
120	yield from self.format_frame(item)	5✔
121	else:
122	yield self.format_repeated_frames(item)	5✔
123
124	def format_repeated_frames(self, repeated_frames: RepeatedFrames) -> str:	5✔
125	return ' [... skipping similar frames: {}]\n'.format(	5✔
126	repeated_frames.description
127	)
128
129	def format_frame(self, frame: Union[FrameInfo, FrameType, TracebackType]) -> Iterable[str]:	5✔
130	if not isinstance(frame, FrameInfo):	5✔
131	frame = FrameInfo(frame, self.options)	5✔
132
133	yield self.format_frame_header(frame)	5✔
134
135	for line in frame.lines:	5✔
136	if isinstance(line, Line):	5✔
137	yield self.format_line(line)	5✔
138	else:
139	assert_(line is LINE_GAP)	5✔
140	yield self.line_gap_string + "\n"	5✔
141
142	if self.show_variables:	5✔
143	try:	5✔
144	yield from self.format_variables(frame)	5✔
UNCOV 145	except Exception:	×
UNCOV 146	pass	×
147
148	def format_frame_header(self, frame_info: FrameInfo) -> str:	5✔
149	return ' File "{frame_info.filename}", line {frame_info.lineno}, in {name}\n'.format(	5✔
150	frame_info=frame_info,
151	name=(
152	frame_info.executing.code_qualname()
153	if self.use_code_qualname else
154	frame_info.code.co_name
155	),
156	)
157
158	def format_line(self, line: Line) -> str:	5✔
159	result = ""	5✔
160	if self.current_line_indicator:	5!
161	if line.is_current:	5✔
162	result = self.current_line_indicator	5✔
163	else:
164	result = " " * len(self.current_line_indicator)	5✔
165	result += " "	5✔
166
167	if self.show_linenos:	5!
168	result += "{:4} \| ".format(line.lineno)	5✔
169
170	result = result or " "	5✔
171
172	prefix = result	5✔
173
174	result += line.render(	5✔
175	pygmented=self.pygmented,
176	escape_html=self.html,
177	strip_leading_indent=self.strip_leading_indent,
178	) + "\n"
179
180	if self.show_executing_node and not self.pygmented:	5✔
181	for line_range in line.executing_node_ranges:	5✔
182	start = line_range.start - line.leading_indent	5✔
183	end = line_range.end - line.leading_indent	5✔
184	result += (	5✔
185	" " * (start + len(prefix))
186	+ self.executing_node_underline * (end - start)
187	+ "\n"
188	)
189
190	return result	5✔
191
192	def format_variables(self, frame_info: FrameInfo) -> Iterable[str]:	5✔
193	for var in sorted(frame_info.variables, key=lambda v: v.name):	5✔
194	try:	5✔
195	yield self.format_variable(var) + "\n"	5✔
UNCOV 196	except Exception:	×
UNCOV 197	pass	×
198
199	def format_variable(self, var: Variable) -> str:	5✔
200	return "{} = {}".format(	5✔
201	var.name,
202	self.format_variable_value(var.value),
203	)
204
205	def format_variable_value(self, value) -> str:	5✔
206	return repr(value)	5✔

alexmojaki / stack_data / 95

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous