CallPrinter.__call__() - Code Metrics - Inspection of "Add note about depth." - ionelmc/python-hunter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( af1fbe...dff617 )

by Ionel Cristian

created 2017-11-23 18:47 UTC

CallPrinter.call() D

↳ Parent: CallPrinter

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
cc	9
c	6
b	1
f	0
dl	0
loc	75
rs	4

How to fix Long Method

from __future__ import absolute_import

import ast
import os
import sys
import threading
from collections import defaultdict
from itertools import chain

from colorama import AnsiToWin32
from colorama import Back
from colorama import Fore
from colorama import Style
from six import string_types

from .util import Fields

EVENT_COLORS = {
    'reset': Style.RESET_ALL,
    'normal': Style.NORMAL,
    'filename': '',
    'colon': Style.BRIGHT + Fore.BLACK,
    'lineno': Style.RESET_ALL,
    'kind': Fore.CYAN,
    'continuation': Style.BRIGHT + Fore.BLUE,
    'call': Style.BRIGHT + Fore.BLUE,
    'return': Style.BRIGHT + Fore.GREEN,
    'exception': Style.BRIGHT + Fore.RED,
    'detail': Style.NORMAL,
    'vars': Style.RESET_ALL + Fore.MAGENTA,
    'vars-name': Style.BRIGHT,
    'internal-failure': Style.BRIGHT + Back.RED + Fore.RED,
    'internal-detail': Fore.WHITE,
    'source-failure': Style.BRIGHT + Back.YELLOW + Fore.YELLOW,
    'source-detail': Fore.WHITE,
}
CODE_COLORS = {
    'call': Fore.RESET + Style.BRIGHT,
    'line': Fore.RESET,
    'return': Fore.YELLOW,
    'exception': Fore.RED,
}
NO_COLORS = {key: '' for key in chain(CODE_COLORS, EVENT_COLORS)}
MISSING = type('MISSING', (), {'__repr__': lambda _: '?'})()


class Action(object):
    def __call__(self, event):
        raise NotImplementedError()


class Debugger(Fields.klass.kwargs, Action):
    """
    An action that starts ``pdb``.
    """
    def __init__(self, klass=lambda **kwargs: __import__('pdb').Pdb(**kwargs), **kwargs):
        self.klass = klass
        self.kwargs = kwargs

    def __call__(self, event):
        """
        Runs a ``pdb.set_trace`` at the matching frame.
        """
        self.klass(**self.kwargs).set_trace(event.frame)


class Manhole(Action):
    def __init__(self, **options):
        self.options = options

    def __call__(self, event):
        import manhole
        inst = manhole.install(strict=False, thread=False, **self.options)
        inst.handle_oneshot()


DEFAULT_STREAM = sys.stderr


class ColorStreamAction(Fields.stream.force_colors.filename_alignment.thread_alignment.repr_limit, Action):
    _stream_cache = {}
    _stream = None
    _tty = None

    def __init__(self,
                 stream=None,
                 force_colors=False,
                 filename_alignment=40,
                 thread_alignment=12,
                 repr_limit=1024):
        self.force_colors = force_colors
        self.stream = DEFAULT_STREAM if stream is None else stream
        self.filename_alignment = filename_alignment
        self.thread_alignment = thread_alignment
        self.repr_limit = repr_limit

    @property
    def stream(self):
        return self._stream

    @stream.setter
    def stream(self, value):
        if isinstance(value, string_types):
            if value in self._stream_cache:
                value = self._stream_cache[value]
            else:
                value = self._stream_cache[value] = open(value, 'a', buffering=0)

        isatty = getattr(value, 'isatty', None)
        if self.force_colors or (isatty and isatty() and os.name != 'java'):
            self._stream = AnsiToWin32(value, strip=False)
            self._tty = True
            self.event_colors = EVENT_COLORS
            self.code_colors = CODE_COLORS
        else:
            self._tty = False
            self._stream = value
            self.event_colors = NO_COLORS
            self.code_colors = NO_COLORS

    def _safe_repr(self, obj):
        limit = self.repr_limit

        try:
            s = repr(obj)
            s = s.replace('\n', r'\n')
            if len(s) > limit:
                cutoff = limit // 2
                return "{} {continuation}[...]{reset} {}".format(s[:cutoff], s[-cutoff:], **self.event_colors)
            else:
                return s
        except Exception as exc:
            return "{internal-failure}!!! FAILED REPR: {internal-detail}{!r}{reset}".format(exc, **self.event_colors)


class CodePrinter(ColorStreamAction):
    """
    An action that just prints the code being executed.

    Args:
        stream (file-like): Stream to write to. Default: ``sys.stderr``.
        filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
        force_colors (bool): Force coloring. Default: ``False``.
        repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.
    """
    def _safe_source(self, event):
        try:
            lines = event._raw_fullsource.rstrip().splitlines()
            if lines:
                return lines
            else:
                return "{source-failure}??? NO SOURCE: {source-detail}" \
                       "Source code string for module {!r} is empty.".format(event.module, **self.event_colors),
            return lines
        except Exception as exc:
            return "{source-failure}??? NO SOURCE: {source-detail}{!r}".format(exc, **self.event_colors),

    def _format_filename(self, event):
        filename = event.filename or "<???>"
        if len(filename) > self.filename_alignment:
            filename = '[...]{}'.format(filename[5 - self.filename_alignment:])
        return filename

    def __call__(self, event, sep=os.path.sep, join=os.path.join):
        """
        Handle event and print filename, line number and source code. If event.kind is a `return` or `exception` also
        prints values.
        """

        # context = event.tracer
        # alignment = context.filename_alignment = max(
        #     getattr(context, 'filename_alignment', 5),
        #     len(filename)
        # )
        lines = self._safe_source(event)
        thread_name = threading.current_thread().name if event.tracer.threading_support else ''
        thread_align = self.thread_alignment if event.tracer.threading_support else ''

        self.stream.write(
            "{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {code}{}{reset}\n".format(
                self._format_filename(event),
                event.lineno,
                event.kind,
                lines[0],
                thread=thread_name, thread_align=thread_align,
                align=self.filename_alignment,
                code=self.code_colors[event.kind],
                **self.event_colors
            ))
        for line in lines[1:]:
            self.stream.write("{thread:{thread_align}}{:>{align}}       {kind}{:9} {code}{}{reset}\n".format(
                "",
                r"   |",
                line,
                thread=thread_name, thread_align=thread_align,
                align=self.filename_alignment,
                code=self.code_colors[event.kind],
                **self.event_colors
            ))

        if event.kind in ('return', 'exception'):
            self.stream.write(
                "{thread:{thread_align}}{:>{align}}       {continuation}{:9} {color}{} "
                "value: {detail}{}{reset}\n".format(
                    "",
                    "...",
                    event.kind,
                    self._safe_repr(event.arg),
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    color=self.event_colors[event.kind],
                    **self.event_colors
                ))


class CallPrinter(CodePrinter):
    """
    An action that just prints the code being executed, but unlike :obj:`hunter.CodePrinter` it indents based on
    callstack depth and it also shows ``repr()`` of function arguments.

    Args:
        stream (file-like): Stream to write to. Default: ``sys.stderr``.
        filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
        force_colors (bool): Force coloring. Default: ``False``.
        repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.

    .. versionadded:: 1.2.0

    .. note::

        This will be the default action in `hunter 2.0`.
    """

    def __init__(self, **options):
        super(CallPrinter, self).__init__(**options)
        self.locals = defaultdict(list)

    def __call__(self, event, sep=os.path.sep, join=os.path.join):
        """
        Handle event and print filename, line number and source code. If event.kind is a `return` or `exception` also
        prints values.
        """
        filename = self._format_filename(event)
        ident = event.module, event.function
        thread = threading.current_thread()
        thread_name = thread.name if event.tracer.threading_support else ''
        thread_align = self.thread_alignment if event.tracer.threading_support else ''
        stack = self.locals[thread.ident]

        if event.kind == 'call':
            code = event.code
            stack.append(ident)
            self.stream.write(
                "{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {}{call}=>{normal} "
                "{}({}{call}{normal}){reset}\n".format(
                    filename,
                    event.lineno,
                    event.kind,
                    '   ' * (len(stack) - 1),
                    event.function,
                    ', '.join('{vars}{vars-name}{0}{vars}={reset}{1}'.format(
                        var,
                        self._safe_repr(event.locals.get(var, MISSING)),
                        **self.event_colors
                    ) for var in code.co_varnames[:code.co_argcount]),
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    **self.event_colors
                ))
        elif event.kind == 'exception':
            self.stream.write(
                "{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} "
                "{exception}{} !{normal} {}: {reset}{}\n".format(
                    filename,
                    event.lineno,
                    event.kind,
                    '   ' * (len(stack) - 1),
                    event.function,
                    self._safe_repr(event.arg),
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    **self.event_colors
                ))

        elif event.kind == 'return':
            self.stream.write(
                "{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} "
                "{return}{}<={normal} {}: {reset}{}\n".format(
                    filename,
                    event.lineno,
                    event.kind,
                    '   ' * (len(stack) - 1),
                    event.function,
                    self._safe_repr(event.arg),
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    **self.event_colors
                ))
            if stack and stack[-1] == ident:
                stack.pop()
        else:
            self.stream.write(
                "{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {reset}{}{}\n".format(
                    filename,
                    event.lineno,
                    event.kind,
                    '   ' * len(stack),
                    event.source.strip(),
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    code=self.code_colors[event.kind],
                    **self.event_colors
                ))


class VarsPrinter(Fields.names.globals.stream.filename_alignment, ColorStreamAction):
    """
    An action that prints local variables and optionally global variables visible from the current executing frame.

    Args:
        *names (strings): Names to evaluate. Expressions can be used (will only try to evaluate if all the variables are
            present on the frame.
        globals (bool): Allow access to globals. Default: ``False`` (only looks at locals).
        stream (file-like): Stream to write to. Default: ``sys.stderr``.
        filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
        force_colors (bool): Force coloring. Default: ``False``.
        repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.
    """

    def __init__(self, *names, **options):
        if not names:
            raise TypeError("VarsPrinter requires at least one variable name/expression.")
        self.names = {
            name: set(self._iter_symbols(name))
            for name in names
        }
        self.globals = options.pop('globals', False)
        super(VarsPrinter, self).__init__(**options)

    @staticmethod
    def _iter_symbols(code):
        """
        Iterate all the variable names in the given expression.

        Example:

        * ``self.foobar`` yields ``self``
        * ``self[foobar]`` yields `self`` and ``foobar``
        """
        for node in ast.walk(ast.parse(code)):
            if isinstance(node, ast.Name):
                yield node.id

    def _safe_eval(self, code, event):
        """
        Try to evaluate the given code on the given frame. If failure occurs, returns some ugly string with exception.
        """
        try:
            return eval(code, event.globals if self.globals else {}, event.locals)
        except Exception as exc:
            return "{internal-failure}FAILED EVAL: {internal-detail}{!r}".format(exc, **self.event_colors)

    def __call__(self, event):
        """
        Handle event and print the specified variables.
        """
        first = True
        frame_symbols = set(event.locals)
        if self.globals:
            frame_symbols |= set(event.globals)
        thread_name = threading.current_thread().name if event.tracer.threading_support else ''
        thread_align = self.thread_alignment if event.tracer.threading_support else ''

        for code, symbols in self.names.items():
            try:
                obj = eval(code, event.globals if self.globals else {}, event.locals)
            except AttributeError:
                continue
            except Exception as exc:
                printout = "{internal-failure}FAILED EVAL: {internal-detail}{!r}".format(exc, **self.event_colors)
            else:
                printout = self._safe_repr(obj)

            if frame_symbols >= symbols:
                self.stream.write("{thread:{thread_align}}{:>{align}}       {vars}{:9} {vars-name}{} {vars}=> {reset}{}{reset}\n".format(
                    "",
                    "vars" if first else "...",
                    code,
                    printout,
                    thread=thread_name, thread_align=thread_align,
                    align=self.filename_alignment,
                    **self.event_colors
                ))
                first = False


1			from __future__ import absolute_import
2
3			import ast
4			import os
5			import sys
6			import threading
7			from collections import defaultdict
8			from itertools import chain
9
10			from colorama import AnsiToWin32
11			from colorama import Back
12			from colorama import Fore
13			from colorama import Style
14			from six import string_types
15
16			from .util import Fields
17
18			EVENT_COLORS = {
19			'reset': Style.RESET_ALL,
20			'normal': Style.NORMAL,
21			'filename': '',
22			'colon': Style.BRIGHT + Fore.BLACK,
23			'lineno': Style.RESET_ALL,
24			'kind': Fore.CYAN,
25			'continuation': Style.BRIGHT + Fore.BLUE,
26			'call': Style.BRIGHT + Fore.BLUE,
27			'return': Style.BRIGHT + Fore.GREEN,
28			'exception': Style.BRIGHT + Fore.RED,
29			'detail': Style.NORMAL,
30			'vars': Style.RESET_ALL + Fore.MAGENTA,
31			'vars-name': Style.BRIGHT,
32			'internal-failure': Style.BRIGHT + Back.RED + Fore.RED,
33			'internal-detail': Fore.WHITE,
34			'source-failure': Style.BRIGHT + Back.YELLOW + Fore.YELLOW,
35			'source-detail': Fore.WHITE,
36			}
37			CODE_COLORS = {
38			'call': Fore.RESET + Style.BRIGHT,
39			'line': Fore.RESET,
40			'return': Fore.YELLOW,
41			'exception': Fore.RED,
42			}
43			NO_COLORS = {key: '' for key in chain(CODE_COLORS, EVENT_COLORS)}
44			MISSING = type('MISSING', (), {'__repr__': lambda _: '?'})()
45
46
47			class Action(object):
48			def __call__(self, event):
49			raise NotImplementedError()
50
51
52			class Debugger(Fields.klass.kwargs, Action):
53			"""
54			An action that starts ``pdb``.
55			"""
56			def __init__(self, klass=lambda kwargs: __import__('pdb').Pdb(kwargs), **kwargs):
57			self.klass = klass
58			self.kwargs = kwargs
59
60			def __call__(self, event):
61			"""
62			Runs a ``pdb.set_trace`` at the matching frame.
63			"""
64			self.klass(**self.kwargs).set_trace(event.frame)
65
66
67			class Manhole(Action):
68			def __init__(self, **options):
69			self.options = options
70
71			def __call__(self, event):
72			import manhole
73			inst = manhole.install(strict=False, thread=False, **self.options)
74			inst.handle_oneshot()
75
76
77			DEFAULT_STREAM = sys.stderr
78
79
80			class ColorStreamAction(Fields.stream.force_colors.filename_alignment.thread_alignment.repr_limit, Action):
81			_stream_cache = {}
82			_stream = None
83			_tty = None
84
85			def __init__(self,
86			stream=None,
87			force_colors=False,
88			filename_alignment=40,
89			thread_alignment=12,
90			repr_limit=1024):
91			self.force_colors = force_colors
92			self.stream = DEFAULT_STREAM if stream is None else stream
93			self.filename_alignment = filename_alignment
94			self.thread_alignment = thread_alignment
95			self.repr_limit = repr_limit
96
97			@property
98			def stream(self):
99			return self._stream
100
101			@stream.setter
102			def stream(self, value):
103			if isinstance(value, string_types):
104			if value in self._stream_cache:
105			value = self._stream_cache[value]
106			else:
107			value = self._stream_cache[value] = open(value, 'a', buffering=0)
108
109			isatty = getattr(value, 'isatty', None)
110			if self.force_colors or (isatty and isatty() and os.name != 'java'):
111			self._stream = AnsiToWin32(value, strip=False)
112			self._tty = True
113			self.event_colors = EVENT_COLORS
114			self.code_colors = CODE_COLORS
115			else:
116			self._tty = False
117			self._stream = value
118			self.event_colors = NO_COLORS
119			self.code_colors = NO_COLORS
120
121			def _safe_repr(self, obj):
122			limit = self.repr_limit
123
124			try:
125			s = repr(obj)
126			s = s.replace('\n', r'\n')
127			if len(s) > limit:
128			cutoff = limit // 2
129			return "{} {continuation}[...]{reset} {}".format(s[:cutoff], s[-cutoff:], **self.event_colors)
130			else:
131			return s
132			except Exception as exc:
133			return "{internal-failure}!!! FAILED REPR: {internal-detail}{!r}{reset}".format(exc, **self.event_colors)
134
135
136			class CodePrinter(ColorStreamAction):
137			"""
138			An action that just prints the code being executed.
139
140			Args:
141			stream (file-like): Stream to write to. Default: ``sys.stderr``.
142			filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
143			force_colors (bool): Force coloring. Default: ``False``.
144			repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.
145			"""
146			def _safe_source(self, event):
147			try:
148			lines = event._raw_fullsource.rstrip().splitlines()
149			if lines:
150			return lines
151			else:
152			return "{source-failure}??? NO SOURCE: {source-detail}" \
153			"Source code string for module {!r} is empty.".format(event.module, **self.event_colors),
154			return lines
155			except Exception as exc:
156			return "{source-failure}??? NO SOURCE: {source-detail}{!r}".format(exc, **self.event_colors),
157
158			def _format_filename(self, event):
159			filename = event.filename or "<???>"
160			if len(filename) > self.filename_alignment:
161			filename = '[...]{}'.format(filename[5 - self.filename_alignment:])
162			return filename
163
164			def __call__(self, event, sep=os.path.sep, join=os.path.join):
165			"""
166			Handle event and print filename, line number and source code. If event.kind is a `return` or `exception` also
167			prints values.
168			"""
169
170			# context = event.tracer
171			# alignment = context.filename_alignment = max(
172			# getattr(context, 'filename_alignment', 5),
173			# len(filename)
174			# )
175			lines = self._safe_source(event)
176			thread_name = threading.current_thread().name if event.tracer.threading_support else ''
177			thread_align = self.thread_alignment if event.tracer.threading_support else ''
178
179			self.stream.write(
180			"{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {code}{}{reset}\n".format(
181			self._format_filename(event),
182			event.lineno,
183			event.kind,
184			lines[0],
185			thread=thread_name, thread_align=thread_align,
186			align=self.filename_alignment,
187			code=self.code_colors[event.kind],
188			**self.event_colors
189			))
190			for line in lines[1:]:
191			self.stream.write("{thread:{thread_align}}{:>{align}} {kind}{:9} {code}{}{reset}\n".format(
192			"",
193			r" \|",
194			line,
195			thread=thread_name, thread_align=thread_align,
196			align=self.filename_alignment,
197			code=self.code_colors[event.kind],
198			**self.event_colors
199			))
200
201			if event.kind in ('return', 'exception'):
202			self.stream.write(
203			"{thread:{thread_align}}{:>{align}} {continuation}{:9} {color}{} "
204			"value: {detail}{}{reset}\n".format(
205			"",
206			"...",
207			event.kind,
208			self._safe_repr(event.arg),
209			thread=thread_name, thread_align=thread_align,
210			align=self.filename_alignment,
211			color=self.event_colors[event.kind],
212			**self.event_colors
213			))
214
215
216			class CallPrinter(CodePrinter):
217			"""
218			An action that just prints the code being executed, but unlike :obj:`hunter.CodePrinter` it indents based on
219			callstack depth and it also shows ``repr()`` of function arguments.
220
221			Args:
222			stream (file-like): Stream to write to. Default: ``sys.stderr``.
223			filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
224			force_colors (bool): Force coloring. Default: ``False``.
225			repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.
226
227			.. versionadded:: 1.2.0
228
229			.. note::
230
231			This will be the default action in `hunter 2.0`.
232			"""
233
234			def __init__(self, **options):
235			super(CallPrinter, self).__init__(**options)
236			self.locals = defaultdict(list)
237
238			def __call__(self, event, sep=os.path.sep, join=os.path.join):
239			"""
240			Handle event and print filename, line number and source code. If event.kind is a `return` or `exception` also
241			prints values.
242			"""
243			filename = self._format_filename(event)
244			ident = event.module, event.function
245			thread = threading.current_thread()
246			thread_name = thread.name if event.tracer.threading_support else ''
247			thread_align = self.thread_alignment if event.tracer.threading_support else ''
248			stack = self.locals[thread.ident]
249
250			if event.kind == 'call':
251			code = event.code
252			stack.append(ident)
253			self.stream.write(
254			"{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {}{call}=>{normal} "
255			"{}({}{call}{normal}){reset}\n".format(
256			filename,
257			event.lineno,
258			event.kind,
259			' ' * (len(stack) - 1),
260			event.function,
261			', '.join('{vars}{vars-name}{0}{vars}={reset}{1}'.format(
262			var,
263			self._safe_repr(event.locals.get(var, MISSING)),
264			**self.event_colors
265			) for var in code.co_varnames[:code.co_argcount]),
266			thread=thread_name, thread_align=thread_align,
267			align=self.filename_alignment,
268			**self.event_colors
269			))
270			elif event.kind == 'exception':
271			self.stream.write(
272			"{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} "
273			"{exception}{} !{normal} {}: {reset}{}\n".format(
274			filename,
275			event.lineno,
276			event.kind,
277			' ' * (len(stack) - 1),
278			event.function,
279			self._safe_repr(event.arg),
280			thread=thread_name, thread_align=thread_align,
281			align=self.filename_alignment,
282			**self.event_colors
283			))
284
285			elif event.kind == 'return':
286			self.stream.write(
287			"{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} "
288			"{return}{}<={normal} {}: {reset}{}\n".format(
289			filename,
290			event.lineno,
291			event.kind,
292			' ' * (len(stack) - 1),
293			event.function,
294			self._safe_repr(event.arg),
295			thread=thread_name, thread_align=thread_align,
296			align=self.filename_alignment,
297			**self.event_colors
298			))
299			if stack and stack[-1] == ident:
300			stack.pop()
301			else:
302			self.stream.write(
303			"{thread:{thread_align}}{filename}{:>{align}}{colon}:{lineno}{:<5} {kind}{:9} {reset}{}{}\n".format(
304			filename,
305			event.lineno,
306			event.kind,
307			' ' * len(stack),
308			event.source.strip(),
309			thread=thread_name, thread_align=thread_align,
310			align=self.filename_alignment,
311			code=self.code_colors[event.kind],
312			**self.event_colors
313			))
314
315
316			class VarsPrinter(Fields.names.globals.stream.filename_alignment, ColorStreamAction):
317			"""
318			An action that prints local variables and optionally global variables visible from the current executing frame.
319
320			Args:
321			*names (strings): Names to evaluate. Expressions can be used (will only try to evaluate if all the variables are
322			present on the frame.
323			globals (bool): Allow access to globals. Default: ``False`` (only looks at locals).
324			stream (file-like): Stream to write to. Default: ``sys.stderr``.
325			filename_alignment (int): Default size for the filename column (files are right-aligned). Default: ``40``.
326			force_colors (bool): Force coloring. Default: ``False``.
327			repr_limit (bool): Limit length of ``repr()`` output. Default: ``512``.
328			"""
329
330			def __init__(self, names, *options):
331			if not names:
332			raise TypeError("VarsPrinter requires at least one variable name/expression.")
333			self.names = {
334			name: set(self._iter_symbols(name))
335			for name in names
336			}
337			self.globals = options.pop('globals', False)
338			super(VarsPrinter, self).__init__(**options)
339
340			@staticmethod
341			def _iter_symbols(code):
342			"""
343			Iterate all the variable names in the given expression.
344
345			Example:
346
347			* ``self.foobar`` yields ``self``
348			* ``self[foobar]`` yields `self`` and ``foobar``
349			"""
350			for node in ast.walk(ast.parse(code)):
351			if isinstance(node, ast.Name):
352			yield node.id
353
354			def _safe_eval(self, code, event):
355			"""
356			Try to evaluate the given code on the given frame. If failure occurs, returns some ugly string with exception.
357			"""
358			try:
359			return eval(code, event.globals if self.globals else {}, event.locals)
360			except Exception as exc:
361			return "{internal-failure}FAILED EVAL: {internal-detail}{!r}".format(exc, **self.event_colors)
362
363			def __call__(self, event):
364			"""
365			Handle event and print the specified variables.
366			"""
367			first = True
368			frame_symbols = set(event.locals)
369			if self.globals:
370			frame_symbols \|= set(event.globals)
371			thread_name = threading.current_thread().name if event.tracer.threading_support else ''
372			thread_align = self.thread_alignment if event.tracer.threading_support else ''
373
374			for code, symbols in self.names.items():
375			try:
376			obj = eval(code, event.globals if self.globals else {}, event.locals)
377			except AttributeError:
378			continue
379			except Exception as exc:
380			printout = "{internal-failure}FAILED EVAL: {internal-detail}{!r}".format(exc, **self.event_colors)
381			else:
382			printout = self._safe_repr(obj)
383
384			if frame_symbols >= symbols:
385			self.stream.write("{thread:{thread_align}}{:>{align}} {vars}{:9} {vars-name}{} {vars}=> {reset}{}{reset}\n".format(
386			"",
387			"vars" if first else "...",
388			code,
389			printout,
390			thread=thread_name, thread_align=thread_align,
391			align=self.filename_alignment,
392			**self.event_colors
393			))
394			first = False
395

ionelmc / python-hunter

Push — master ( af1fbe...dff617 )

CallPrinter.__call__() D

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

CallPrinter.call() D