| # Author: Fred L. Drake, Jr. |
| # fdrake@acm.org |
| # |
| # This is a simple little module I wrote to make life easier. I didn't |
| # see anything quite like it in the library, though I may have overlooked |
| # something. I wrote this when I was trying to read some heavily nested |
| # tuples with fairly non-descriptive content. This is modeled very much |
| # after Lisp/Scheme - style pretty-printing of lists. If you find it |
| # useful, thank small children who sleep at night. |
| |
| """Support to pretty-print lists, tuples, & dictionaries recursively. |
| |
| Very simple, but useful, especially in debugging data structures. |
| |
| Classes |
| ------- |
| |
| PrettyPrinter() |
| Handle pretty-printing operations onto a stream using a configured |
| set of formatting parameters. |
| |
| Functions |
| --------- |
| |
| pformat() |
| Format a Python object into a pretty-printed representation. |
| |
| pprint() |
| Pretty-print a Python object to a stream [default is sys.stdout]. |
| |
| saferepr() |
| Generate a 'standard' repr()-like value, but protect against recursive |
| data structures. |
| |
| """ |
| |
| import sys as _sys |
| import warnings |
| |
| from cStringIO import StringIO as _StringIO |
| |
| __all__ = ["pprint","pformat","isreadable","isrecursive","saferepr", |
| "PrettyPrinter"] |
| |
| # cache these for faster access: |
| _commajoin = ", ".join |
| _id = id |
| _len = len |
| _type = type |
| |
| |
| def pprint(object, stream=None, indent=1, width=80, depth=None): |
| """Pretty-print a Python object to a stream [default is sys.stdout].""" |
| printer = PrettyPrinter( |
| stream=stream, indent=indent, width=width, depth=depth) |
| printer.pprint(object) |
| |
| def pformat(object, indent=1, width=80, depth=None): |
| """Format a Python object into a pretty-printed representation.""" |
| return PrettyPrinter(indent=indent, width=width, depth=depth).pformat(object) |
| |
| def saferepr(object): |
| """Version of repr() which can handle recursive data structures.""" |
| return _safe_repr(object, {}, None, 0)[0] |
| |
| def isreadable(object): |
| """Determine if saferepr(object) is readable by eval().""" |
| return _safe_repr(object, {}, None, 0)[1] |
| |
| def isrecursive(object): |
| """Determine if object requires a recursive representation.""" |
| return _safe_repr(object, {}, None, 0)[2] |
| |
| def _sorted(iterable): |
| with warnings.catch_warnings(): |
| if _sys.py3kwarning: |
| warnings.filterwarnings("ignore", "comparing unequal types " |
| "not supported", DeprecationWarning) |
| return sorted(iterable) |
| |
| class PrettyPrinter: |
| def __init__(self, indent=1, width=80, depth=None, stream=None): |
| """Handle pretty printing operations onto a stream using a set of |
| configured parameters. |
| |
| indent |
| Number of spaces to indent for each level of nesting. |
| |
| width |
| Attempted maximum number of columns in the output. |
| |
| depth |
| The maximum depth to print out nested structures. |
| |
| stream |
| The desired output stream. If omitted (or false), the standard |
| output stream available at construction will be used. |
| |
| """ |
| indent = int(indent) |
| width = int(width) |
| assert indent >= 0, "indent must be >= 0" |
| assert depth is None or depth > 0, "depth must be > 0" |
| assert width, "width must be != 0" |
| self._depth = depth |
| self._indent_per_level = indent |
| self._width = width |
| if stream is not None: |
| self._stream = stream |
| else: |
| self._stream = _sys.stdout |
| |
| def pprint(self, object): |
| self._format(object, self._stream, 0, 0, {}, 0) |
| self._stream.write("\n") |
| |
| def pformat(self, object): |
| sio = _StringIO() |
| self._format(object, sio, 0, 0, {}, 0) |
| return sio.getvalue() |
| |
| def isrecursive(self, object): |
| return self.format(object, {}, 0, 0)[2] |
| |
| def isreadable(self, object): |
| s, readable, recursive = self.format(object, {}, 0, 0) |
| return readable and not recursive |
| |
| def _format(self, object, stream, indent, allowance, context, level): |
| level = level + 1 |
| objid = _id(object) |
| if objid in context: |
| stream.write(_recursion(object)) |
| self._recursive = True |
| self._readable = False |
| return |
| rep = self._repr(object, context, level - 1) |
| typ = _type(object) |
| sepLines = _len(rep) > (self._width - 1 - indent - allowance) |
| write = stream.write |
| |
| if self._depth and level > self._depth: |
| write(rep) |
| return |
| |
| r = getattr(typ, "__repr__", None) |
| if issubclass(typ, dict) and r is dict.__repr__: |
| write('{') |
| if self._indent_per_level > 1: |
| write((self._indent_per_level - 1) * ' ') |
| length = _len(object) |
| if length: |
| context[objid] = 1 |
| indent = indent + self._indent_per_level |
| items = _sorted(object.items()) |
| key, ent = items[0] |
| rep = self._repr(key, context, level) |
| write(rep) |
| write(': ') |
| self._format(ent, stream, indent + _len(rep) + 2, |
| allowance + 1, context, level) |
| if length > 1: |
| for key, ent in items[1:]: |
| rep = self._repr(key, context, level) |
| if sepLines: |
| write(',\n%s%s: ' % (' '*indent, rep)) |
| else: |
| write(', %s: ' % rep) |
| self._format(ent, stream, indent + _len(rep) + 2, |
| allowance + 1, context, level) |
| indent = indent - self._indent_per_level |
| del context[objid] |
| write('}') |
| return |
| |
| if ((issubclass(typ, list) and r is list.__repr__) or |
| (issubclass(typ, tuple) and r is tuple.__repr__) or |
| (issubclass(typ, set) and r is set.__repr__) or |
| (issubclass(typ, frozenset) and r is frozenset.__repr__) |
| ): |
| length = _len(object) |
| if issubclass(typ, list): |
| write('[') |
| endchar = ']' |
| elif issubclass(typ, set): |
| if not length: |
| write('set()') |
| return |
| write('set([') |
| endchar = '])' |
| object = _sorted(object) |
| indent += 4 |
| elif issubclass(typ, frozenset): |
| if not length: |
| write('frozenset()') |
| return |
| write('frozenset([') |
| endchar = '])' |
| object = _sorted(object) |
| indent += 10 |
| else: |
| write('(') |
| endchar = ')' |
| if self._indent_per_level > 1 and sepLines: |
| write((self._indent_per_level - 1) * ' ') |
| if length: |
| context[objid] = 1 |
| indent = indent + self._indent_per_level |
| self._format(object[0], stream, indent, allowance + 1, |
| context, level) |
| if length > 1: |
| for ent in object[1:]: |
| if sepLines: |
| write(',\n' + ' '*indent) |
| else: |
| write(', ') |
| self._format(ent, stream, indent, |
| allowance + 1, context, level) |
| indent = indent - self._indent_per_level |
| del context[objid] |
| if issubclass(typ, tuple) and length == 1: |
| write(',') |
| write(endchar) |
| return |
| |
| write(rep) |
| |
| def _repr(self, object, context, level): |
| repr, readable, recursive = self.format(object, context.copy(), |
| self._depth, level) |
| if not readable: |
| self._readable = False |
| if recursive: |
| self._recursive = True |
| return repr |
| |
| def format(self, object, context, maxlevels, level): |
| """Format object for a specific context, returning a string |
| and flags indicating whether the representation is 'readable' |
| and whether the object represents a recursive construct. |
| """ |
| return _safe_repr(object, context, maxlevels, level) |
| |
| |
| # Return triple (repr_string, isreadable, isrecursive). |
| |
| def _safe_repr(object, context, maxlevels, level): |
| typ = _type(object) |
| if typ is str: |
| if 'locale' not in _sys.modules: |
| return repr(object), True, False |
| if "'" in object and '"' not in object: |
| closure = '"' |
| quotes = {'"': '\\"'} |
| else: |
| closure = "'" |
| quotes = {"'": "\\'"} |
| qget = quotes.get |
| sio = _StringIO() |
| write = sio.write |
| for char in object: |
| if char.isalpha(): |
| write(char) |
| else: |
| write(qget(char, repr(char)[1:-1])) |
| return ("%s%s%s" % (closure, sio.getvalue(), closure)), True, False |
| |
| r = getattr(typ, "__repr__", None) |
| if issubclass(typ, dict) and r is dict.__repr__: |
| if not object: |
| return "{}", True, False |
| objid = _id(object) |
| if maxlevels and level >= maxlevels: |
| return "{...}", False, objid in context |
| if objid in context: |
| return _recursion(object), False, True |
| context[objid] = 1 |
| readable = True |
| recursive = False |
| components = [] |
| append = components.append |
| level += 1 |
| saferepr = _safe_repr |
| for k, v in _sorted(object.items()): |
| krepr, kreadable, krecur = saferepr(k, context, maxlevels, level) |
| vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level) |
| append("%s: %s" % (krepr, vrepr)) |
| readable = readable and kreadable and vreadable |
| if krecur or vrecur: |
| recursive = True |
| del context[objid] |
| return "{%s}" % _commajoin(components), readable, recursive |
| |
| if (issubclass(typ, list) and r is list.__repr__) or \ |
| (issubclass(typ, tuple) and r is tuple.__repr__): |
| if issubclass(typ, list): |
| if not object: |
| return "[]", True, False |
| format = "[%s]" |
| elif _len(object) == 1: |
| format = "(%s,)" |
| else: |
| if not object: |
| return "()", True, False |
| format = "(%s)" |
| objid = _id(object) |
| if maxlevels and level >= maxlevels: |
| return format % "...", False, objid in context |
| if objid in context: |
| return _recursion(object), False, True |
| context[objid] = 1 |
| readable = True |
| recursive = False |
| components = [] |
| append = components.append |
| level += 1 |
| for o in object: |
| orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level) |
| append(orepr) |
| if not oreadable: |
| readable = False |
| if orecur: |
| recursive = True |
| del context[objid] |
| return format % _commajoin(components), readable, recursive |
| |
| rep = repr(object) |
| return rep, (rep and not rep.startswith('<')), False |
| |
| |
| def _recursion(object): |
| return ("<Recursion on %s with id=%s>" |
| % (_type(object).__name__, _id(object))) |
| |
| |
| def _perfcheck(object=None): |
| import time |
| if object is None: |
| object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000 |
| p = PrettyPrinter() |
| t1 = time.time() |
| _safe_repr(object, {}, None, 0) |
| t2 = time.time() |
| p.pformat(object) |
| t3 = time.time() |
| print "_safe_repr:", t2 - t1 |
| print "pformat:", t3 - t2 |
| |
| if __name__ == "__main__": |
| _perfcheck() |
