Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 1 | # Author: Fred L. Drake, Jr. |
Fred Drake | 3e5e661 | 2001-10-09 20:53:48 +0000 | [diff] [blame] | 2 | # fdrake@acm.org |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 3 | # |
| 4 | # This is a simple little module I wrote to make life easier. I didn't |
| 5 | # see anything quite like it in the library, though I may have overlooked |
| 6 | # something. I wrote this when I was trying to read some heavily nested |
Thomas Wouters | 7e47402 | 2000-07-16 12:04:32 +0000 | [diff] [blame] | 7 | # tuples with fairly non-descriptive content. This is modeled very much |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 8 | # after Lisp/Scheme - style pretty-printing of lists. If you find it |
| 9 | # useful, thank small children who sleep at night. |
| 10 | |
| 11 | """Support to pretty-print lists, tuples, & dictionaries recursively. |
| 12 | |
| 13 | Very simple, but useful, especially in debugging data structures. |
| 14 | |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 15 | Classes |
| 16 | ------- |
| 17 | |
| 18 | PrettyPrinter() |
| 19 | Handle pretty-printing operations onto a stream using a configured |
| 20 | set of formatting parameters. |
| 21 | |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 22 | Functions |
| 23 | --------- |
| 24 | |
| 25 | pformat() |
| 26 | Format a Python object into a pretty-printed representation. |
| 27 | |
| 28 | pprint() |
Skip Montanaro | 2dc0c13 | 2004-05-14 16:31:56 +0000 | [diff] [blame] | 29 | Pretty-print a Python object to a stream [default is sys.stdout]. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 30 | |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 31 | saferepr() |
| 32 | Generate a 'standard' repr()-like value, but protect against recursive |
| 33 | data structures. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 34 | |
| 35 | """ |
| 36 | |
Antoine Pitrou | 64c16c3 | 2013-03-23 20:30:39 +0100 | [diff] [blame] | 37 | import re |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 38 | import sys as _sys |
Raymond Hettinger | bad3c88 | 2010-09-09 12:31:00 +0000 | [diff] [blame] | 39 | from collections import OrderedDict as _OrderedDict |
Guido van Rossum | 34d1928 | 2007-08-09 01:03:29 +0000 | [diff] [blame] | 40 | from io import StringIO as _StringIO |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 41 | |
Skip Montanaro | c62c81e | 2001-02-12 02:00:42 +0000 | [diff] [blame] | 42 | __all__ = ["pprint","pformat","isreadable","isrecursive","saferepr", |
| 43 | "PrettyPrinter"] |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 44 | |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 45 | # cache these for faster access: |
| 46 | _commajoin = ", ".join |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 47 | _id = id |
| 48 | _len = len |
| 49 | _type = type |
| 50 | |
| 51 | |
Walter Dörwald | c8de458 | 2003-12-03 20:26:05 +0000 | [diff] [blame] | 52 | def pprint(object, stream=None, indent=1, width=80, depth=None): |
Skip Montanaro | 2dc0c13 | 2004-05-14 16:31:56 +0000 | [diff] [blame] | 53 | """Pretty-print a Python object to a stream [default is sys.stdout].""" |
Walter Dörwald | c8de458 | 2003-12-03 20:26:05 +0000 | [diff] [blame] | 54 | printer = PrettyPrinter( |
| 55 | stream=stream, indent=indent, width=width, depth=depth) |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 56 | printer.pprint(object) |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 57 | |
Walter Dörwald | c8de458 | 2003-12-03 20:26:05 +0000 | [diff] [blame] | 58 | def pformat(object, indent=1, width=80, depth=None): |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 59 | """Format a Python object into a pretty-printed representation.""" |
Walter Dörwald | c8de458 | 2003-12-03 20:26:05 +0000 | [diff] [blame] | 60 | return PrettyPrinter(indent=indent, width=width, depth=depth).pformat(object) |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 61 | |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 62 | def saferepr(object): |
| 63 | """Version of repr() which can handle recursive data structures.""" |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 64 | return _safe_repr(object, {}, None, 0)[0] |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 65 | |
Tim Peters | a814db5 | 2001-05-14 07:05:58 +0000 | [diff] [blame] | 66 | def isreadable(object): |
| 67 | """Determine if saferepr(object) is readable by eval().""" |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 68 | return _safe_repr(object, {}, None, 0)[1] |
Tim Peters | a814db5 | 2001-05-14 07:05:58 +0000 | [diff] [blame] | 69 | |
| 70 | def isrecursive(object): |
| 71 | """Determine if object requires a recursive representation.""" |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 72 | return _safe_repr(object, {}, None, 0)[2] |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 73 | |
Raymond Hettinger | a7da166 | 2009-11-19 01:07:05 +0000 | [diff] [blame] | 74 | class _safe_key: |
| 75 | """Helper function for key functions when sorting unorderable objects. |
| 76 | |
| 77 | The wrapped-object will fallback to an Py2.x style comparison for |
| 78 | unorderable types (sorting first comparing the type name and then by |
| 79 | the obj ids). Does not work recursively, so dict.items() must have |
| 80 | _safe_key applied to both the key and the value. |
| 81 | |
| 82 | """ |
| 83 | |
| 84 | __slots__ = ['obj'] |
| 85 | |
| 86 | def __init__(self, obj): |
| 87 | self.obj = obj |
| 88 | |
| 89 | def __lt__(self, other): |
Florent Xicluna | d6da90f | 2012-07-21 11:17:38 +0200 | [diff] [blame] | 90 | try: |
| 91 | rv = self.obj.__lt__(other.obj) |
| 92 | except TypeError: |
| 93 | rv = NotImplemented |
| 94 | |
Raymond Hettinger | a7da166 | 2009-11-19 01:07:05 +0000 | [diff] [blame] | 95 | if rv is NotImplemented: |
| 96 | rv = (str(type(self.obj)), id(self.obj)) < \ |
| 97 | (str(type(other.obj)), id(other.obj)) |
| 98 | return rv |
| 99 | |
| 100 | def _safe_tuple(t): |
| 101 | "Helper function for comparing 2-tuples" |
| 102 | return _safe_key(t[0]), _safe_key(t[1]) |
| 103 | |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 104 | class PrettyPrinter: |
| 105 | def __init__(self, indent=1, width=80, depth=None, stream=None): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 106 | """Handle pretty printing operations onto a stream using a set of |
| 107 | configured parameters. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 108 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 109 | indent |
| 110 | Number of spaces to indent for each level of nesting. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 111 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 112 | width |
| 113 | Attempted maximum number of columns in the output. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 114 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 115 | depth |
| 116 | The maximum depth to print out nested structures. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 117 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 118 | stream |
| 119 | The desired output stream. If omitted (or false), the standard |
| 120 | output stream available at construction will be used. |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 121 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 122 | """ |
| 123 | indent = int(indent) |
| 124 | width = int(width) |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 125 | assert indent >= 0, "indent must be >= 0" |
Tim Peters | a814db5 | 2001-05-14 07:05:58 +0000 | [diff] [blame] | 126 | assert depth is None or depth > 0, "depth must be > 0" |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 127 | assert width, "width must be != 0" |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 128 | self._depth = depth |
| 129 | self._indent_per_level = indent |
| 130 | self._width = width |
Raymond Hettinger | 16e3c42 | 2002-06-01 16:07:16 +0000 | [diff] [blame] | 131 | if stream is not None: |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 132 | self._stream = stream |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 133 | else: |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 134 | self._stream = _sys.stdout |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 135 | |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 136 | def pprint(self, object): |
Walter Dörwald | e62e936 | 2005-11-11 18:18:51 +0000 | [diff] [blame] | 137 | self._format(object, self._stream, 0, 0, {}, 0) |
| 138 | self._stream.write("\n") |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 139 | |
| 140 | def pformat(self, object): |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 141 | sio = _StringIO() |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 142 | self._format(object, sio, 0, 0, {}, 0) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 143 | return sio.getvalue() |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 144 | |
Fred Drake | e0ffabe | 1997-07-18 20:42:39 +0000 | [diff] [blame] | 145 | def isrecursive(self, object): |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 146 | return self.format(object, {}, 0, 0)[2] |
Fred Drake | e0ffabe | 1997-07-18 20:42:39 +0000 | [diff] [blame] | 147 | |
| 148 | def isreadable(self, object): |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 149 | s, readable, recursive = self.format(object, {}, 0, 0) |
Fred Drake | aee113d | 2002-04-02 05:08:35 +0000 | [diff] [blame] | 150 | return readable and not recursive |
Fred Drake | e0ffabe | 1997-07-18 20:42:39 +0000 | [diff] [blame] | 151 | |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 152 | def _format(self, object, stream, indent, allowance, context, level): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 153 | level = level + 1 |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 154 | objid = _id(object) |
| 155 | if objid in context: |
| 156 | stream.write(_recursion(object)) |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 157 | self._recursive = True |
| 158 | self._readable = False |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 159 | return |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 160 | rep = self._repr(object, context, level - 1) |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 161 | typ = _type(object) |
Antoine Pitrou | 64c16c3 | 2013-03-23 20:30:39 +0100 | [diff] [blame] | 162 | max_width = self._width - 1 - indent - allowance |
| 163 | sepLines = _len(rep) > max_width |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 164 | write = stream.write |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 165 | |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 166 | if sepLines: |
Walter Dörwald | 1b626ca | 2004-11-15 13:51:41 +0000 | [diff] [blame] | 167 | r = getattr(typ, "__repr__", None) |
Raymond Hettinger | bad3c88 | 2010-09-09 12:31:00 +0000 | [diff] [blame] | 168 | if issubclass(typ, dict): |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 169 | write('{') |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 170 | if self._indent_per_level > 1: |
| 171 | write((self._indent_per_level - 1) * ' ') |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 172 | length = _len(object) |
| 173 | if length: |
| 174 | context[objid] = 1 |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 175 | indent = indent + self._indent_per_level |
Raymond Hettinger | bad3c88 | 2010-09-09 12:31:00 +0000 | [diff] [blame] | 176 | if issubclass(typ, _OrderedDict): |
| 177 | items = list(object.items()) |
| 178 | else: |
| 179 | items = sorted(object.items(), key=_safe_tuple) |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 180 | key, ent = items[0] |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 181 | rep = self._repr(key, context, level) |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 182 | write(rep) |
| 183 | write(': ') |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 184 | self._format(ent, stream, indent + _len(rep) + 2, |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 185 | allowance + 1, context, level) |
| 186 | if length > 1: |
| 187 | for key, ent in items[1:]: |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 188 | rep = self._repr(key, context, level) |
Barry Warsaw | 00859c0 | 2001-11-28 05:49:39 +0000 | [diff] [blame] | 189 | write(',\n%s%s: ' % (' '*indent, rep)) |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 190 | self._format(ent, stream, indent + _len(rep) + 2, |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 191 | allowance + 1, context, level) |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 192 | indent = indent - self._indent_per_level |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 193 | del context[objid] |
| 194 | write('}') |
| 195 | return |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 196 | |
Christian Heimes | 1af737c | 2008-01-23 08:24:23 +0000 | [diff] [blame] | 197 | if ((issubclass(typ, list) and r is list.__repr__) or |
| 198 | (issubclass(typ, tuple) and r is tuple.__repr__) or |
| 199 | (issubclass(typ, set) and r is set.__repr__) or |
| 200 | (issubclass(typ, frozenset) and r is frozenset.__repr__) |
| 201 | ): |
Christian Heimes | 969fe57 | 2008-01-25 11:23:10 +0000 | [diff] [blame] | 202 | length = _len(object) |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 203 | if issubclass(typ, list): |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 204 | write('[') |
| 205 | endchar = ']' |
Christian Heimes | 1af737c | 2008-01-23 08:24:23 +0000 | [diff] [blame] | 206 | elif issubclass(typ, set): |
Christian Heimes | 969fe57 | 2008-01-25 11:23:10 +0000 | [diff] [blame] | 207 | if not length: |
| 208 | write('set()') |
| 209 | return |
Christian Heimes | 1af737c | 2008-01-23 08:24:23 +0000 | [diff] [blame] | 210 | write('{') |
| 211 | endchar = '}' |
Raymond Hettinger | a7da166 | 2009-11-19 01:07:05 +0000 | [diff] [blame] | 212 | object = sorted(object, key=_safe_key) |
Christian Heimes | 1af737c | 2008-01-23 08:24:23 +0000 | [diff] [blame] | 213 | elif issubclass(typ, frozenset): |
Christian Heimes | 969fe57 | 2008-01-25 11:23:10 +0000 | [diff] [blame] | 214 | if not length: |
| 215 | write('frozenset()') |
| 216 | return |
Raymond Hettinger | 4b8db41 | 2008-01-31 01:10:03 +0000 | [diff] [blame] | 217 | write('frozenset({') |
| 218 | endchar = '})' |
Raymond Hettinger | a7da166 | 2009-11-19 01:07:05 +0000 | [diff] [blame] | 219 | object = sorted(object, key=_safe_key) |
Christian Heimes | 969fe57 | 2008-01-25 11:23:10 +0000 | [diff] [blame] | 220 | indent += 10 |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 221 | else: |
| 222 | write('(') |
| 223 | endchar = ')' |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 224 | if self._indent_per_level > 1: |
| 225 | write((self._indent_per_level - 1) * ' ') |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 226 | if length: |
| 227 | context[objid] = 1 |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 228 | indent = indent + self._indent_per_level |
| 229 | self._format(object[0], stream, indent, allowance + 1, |
| 230 | context, level) |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 231 | if length > 1: |
| 232 | for ent in object[1:]: |
| 233 | write(',\n' + ' '*indent) |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 234 | self._format(ent, stream, indent, |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 235 | allowance + 1, context, level) |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 236 | indent = indent - self._indent_per_level |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 237 | del context[objid] |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 238 | if issubclass(typ, tuple) and length == 1: |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 239 | write(',') |
| 240 | write(endchar) |
| 241 | return |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 242 | |
Antoine Pitrou | 64c16c3 | 2013-03-23 20:30:39 +0100 | [diff] [blame] | 243 | if issubclass(typ, str) and len(object) > 0 and r is str.__repr__: |
| 244 | def _str_parts(s): |
| 245 | """ |
| 246 | Return a list of string literals comprising the repr() |
| 247 | of the given string using literal concatenation. |
| 248 | """ |
| 249 | lines = s.splitlines(True) |
| 250 | for i, line in enumerate(lines): |
| 251 | rep = repr(line) |
| 252 | if _len(rep) <= max_width: |
| 253 | yield rep |
| 254 | else: |
| 255 | # A list of alternating (non-space, space) strings |
| 256 | parts = re.split(r'(\s+)', line) + [''] |
| 257 | current = '' |
| 258 | for i in range(0, len(parts), 2): |
| 259 | part = parts[i] + parts[i+1] |
| 260 | candidate = current + part |
| 261 | if len(repr(candidate)) > max_width: |
| 262 | if current: |
| 263 | yield repr(current) |
| 264 | current = part |
| 265 | else: |
| 266 | current = candidate |
| 267 | if current: |
| 268 | yield repr(current) |
| 269 | for i, rep in enumerate(_str_parts(object)): |
| 270 | if i > 0: |
| 271 | write('\n' + ' '*indent) |
| 272 | write(rep) |
| 273 | return |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 274 | write(rep) |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 275 | |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 276 | def _repr(self, object, context, level): |
Fred Drake | aee113d | 2002-04-02 05:08:35 +0000 | [diff] [blame] | 277 | repr, readable, recursive = self.format(object, context.copy(), |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 278 | self._depth, level) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 279 | if not readable: |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 280 | self._readable = False |
Tim Peters | a814db5 | 2001-05-14 07:05:58 +0000 | [diff] [blame] | 281 | if recursive: |
Fred Drake | e6691ef | 2002-07-08 12:28:06 +0000 | [diff] [blame] | 282 | self._recursive = True |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 283 | return repr |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 284 | |
Fred Drake | aee113d | 2002-04-02 05:08:35 +0000 | [diff] [blame] | 285 | def format(self, object, context, maxlevels, level): |
| 286 | """Format object for a specific context, returning a string |
| 287 | and flags indicating whether the representation is 'readable' |
| 288 | and whether the object represents a recursive construct. |
| 289 | """ |
| 290 | return _safe_repr(object, context, maxlevels, level) |
| 291 | |
| 292 | |
Tim Peters | a814db5 | 2001-05-14 07:05:58 +0000 | [diff] [blame] | 293 | # Return triple (repr_string, isreadable, isrecursive). |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 294 | |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 295 | def _safe_repr(object, context, maxlevels, level): |
| 296 | typ = _type(object) |
Martin v. Löwis | d02879d | 2003-06-07 20:47:37 +0000 | [diff] [blame] | 297 | if typ is str: |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 298 | if 'locale' not in _sys.modules: |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 299 | return repr(object), True, False |
Fred Drake | 1ef106c | 2001-09-04 19:43:26 +0000 | [diff] [blame] | 300 | if "'" in object and '"' not in object: |
| 301 | closure = '"' |
| 302 | quotes = {'"': '\\"'} |
| 303 | else: |
| 304 | closure = "'" |
| 305 | quotes = {"'": "\\'"} |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 306 | qget = quotes.get |
Fred Drake | 397b615 | 2002-12-31 07:14:18 +0000 | [diff] [blame] | 307 | sio = _StringIO() |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 308 | write = sio.write |
Fred Drake | 1ef106c | 2001-09-04 19:43:26 +0000 | [diff] [blame] | 309 | for char in object: |
| 310 | if char.isalpha(): |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 311 | write(char) |
Fred Drake | 1ef106c | 2001-09-04 19:43:26 +0000 | [diff] [blame] | 312 | else: |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 313 | write(qget(char, repr(char)[1:-1])) |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 314 | return ("%s%s%s" % (closure, sio.getvalue(), closure)), True, False |
Tim Peters | 95b3f78 | 2001-05-14 18:39:41 +0000 | [diff] [blame] | 315 | |
Walter Dörwald | 1b626ca | 2004-11-15 13:51:41 +0000 | [diff] [blame] | 316 | r = getattr(typ, "__repr__", None) |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 317 | if issubclass(typ, dict) and r is dict.__repr__: |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 318 | if not object: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 319 | return "{}", True, False |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 320 | objid = _id(object) |
Alexandre Vassalotti | eca20b6 | 2008-05-16 02:54:33 +0000 | [diff] [blame] | 321 | if maxlevels and level >= maxlevels: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 322 | return "{...}", False, objid in context |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 323 | if objid in context: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 324 | return _recursion(object), False, True |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 325 | context[objid] = 1 |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 326 | readable = True |
| 327 | recursive = False |
Tim Peters | 95b3f78 | 2001-05-14 18:39:41 +0000 | [diff] [blame] | 328 | components = [] |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 329 | append = components.append |
| 330 | level += 1 |
| 331 | saferepr = _safe_repr |
Raymond Hettinger | a7da166 | 2009-11-19 01:07:05 +0000 | [diff] [blame] | 332 | items = sorted(object.items(), key=_safe_tuple) |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 333 | for k, v in items: |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 334 | krepr, kreadable, krecur = saferepr(k, context, maxlevels, level) |
| 335 | vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level) |
| 336 | append("%s: %s" % (krepr, vrepr)) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 337 | readable = readable and kreadable and vreadable |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 338 | if krecur or vrecur: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 339 | recursive = True |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 340 | del context[objid] |
| 341 | return "{%s}" % _commajoin(components), readable, recursive |
Tim Peters | 95b3f78 | 2001-05-14 18:39:41 +0000 | [diff] [blame] | 342 | |
Walter Dörwald | 7a7ede5 | 2003-12-03 20:15:28 +0000 | [diff] [blame] | 343 | if (issubclass(typ, list) and r is list.__repr__) or \ |
| 344 | (issubclass(typ, tuple) and r is tuple.__repr__): |
| 345 | if issubclass(typ, list): |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 346 | if not object: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 347 | return "[]", True, False |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 348 | format = "[%s]" |
| 349 | elif _len(object) == 1: |
| 350 | format = "(%s,)" |
| 351 | else: |
| 352 | if not object: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 353 | return "()", True, False |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 354 | format = "(%s)" |
| 355 | objid = _id(object) |
Alexandre Vassalotti | eca20b6 | 2008-05-16 02:54:33 +0000 | [diff] [blame] | 356 | if maxlevels and level >= maxlevels: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 357 | return format % "...", False, objid in context |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 358 | if objid in context: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 359 | return _recursion(object), False, True |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 360 | context[objid] = 1 |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 361 | readable = True |
| 362 | recursive = False |
Tim Peters | 95b3f78 | 2001-05-14 18:39:41 +0000 | [diff] [blame] | 363 | components = [] |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 364 | append = components.append |
| 365 | level += 1 |
| 366 | for o in object: |
| 367 | orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level) |
| 368 | append(orepr) |
| 369 | if not oreadable: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 370 | readable = False |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 371 | if orecur: |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 372 | recursive = True |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 373 | del context[objid] |
| 374 | return format % _commajoin(components), readable, recursive |
Tim Peters | 8876848 | 2001-11-13 21:51:26 +0000 | [diff] [blame] | 375 | |
Walter Dörwald | 70a6b49 | 2004-02-12 17:35:32 +0000 | [diff] [blame] | 376 | rep = repr(object) |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 377 | return rep, (rep and not rep.startswith('<')), False |
Tim Peters | 95b3f78 | 2001-05-14 18:39:41 +0000 | [diff] [blame] | 378 | |
Guido van Rossum | 5e92aff | 1997-04-16 00:49:59 +0000 | [diff] [blame] | 379 | |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 380 | def _recursion(object): |
| 381 | return ("<Recursion on %s with id=%s>" |
| 382 | % (_type(object).__name__, _id(object))) |
Fred Drake | a89fda0 | 1997-04-16 16:59:30 +0000 | [diff] [blame] | 383 | |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 384 | |
| 385 | def _perfcheck(object=None): |
| 386 | import time |
| 387 | if object is None: |
| 388 | object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000 |
| 389 | p = PrettyPrinter() |
| 390 | t1 = time.time() |
| 391 | _safe_repr(object, {}, None, 0) |
| 392 | t2 = time.time() |
| 393 | p.pformat(object) |
| 394 | t3 = time.time() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 395 | print("_safe_repr:", t2 - t1) |
| 396 | print("pformat:", t3 - t2) |
Fred Drake | 49cc01e | 2001-11-01 17:50:38 +0000 | [diff] [blame] | 397 | |
| 398 | if __name__ == "__main__": |
| 399 | _perfcheck() |