##// END OF EJS Templates
Remove extra indentation.
Frazer McLean -
Show More
@@ -1,847 +1,847 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """
2 """
3 Python advanced pretty printer. This pretty printer is intended to
3 Python advanced pretty printer. This pretty printer is intended to
4 replace the old `pprint` python module which does not allow developers
4 replace the old `pprint` python module which does not allow developers
5 to provide their own pretty print callbacks.
5 to provide their own pretty print callbacks.
6
6
7 This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
7 This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
8
8
9
9
10 Example Usage
10 Example Usage
11 -------------
11 -------------
12
12
13 To directly print the representation of an object use `pprint`::
13 To directly print the representation of an object use `pprint`::
14
14
15 from pretty import pprint
15 from pretty import pprint
16 pprint(complex_object)
16 pprint(complex_object)
17
17
18 To get a string of the output use `pretty`::
18 To get a string of the output use `pretty`::
19
19
20 from pretty import pretty
20 from pretty import pretty
21 string = pretty(complex_object)
21 string = pretty(complex_object)
22
22
23
23
24 Extending
24 Extending
25 ---------
25 ---------
26
26
27 The pretty library allows developers to add pretty printing rules for their
27 The pretty library allows developers to add pretty printing rules for their
28 own objects. This process is straightforward. All you have to do is to
28 own objects. This process is straightforward. All you have to do is to
29 add a `_repr_pretty_` method to your object and call the methods on the
29 add a `_repr_pretty_` method to your object and call the methods on the
30 pretty printer passed::
30 pretty printer passed::
31
31
32 class MyObject(object):
32 class MyObject(object):
33
33
34 def _repr_pretty_(self, p, cycle):
34 def _repr_pretty_(self, p, cycle):
35 ...
35 ...
36
36
37 Here is an example implementation of a `_repr_pretty_` method for a list
37 Here is an example implementation of a `_repr_pretty_` method for a list
38 subclass::
38 subclass::
39
39
40 class MyList(list):
40 class MyList(list):
41
41
42 def _repr_pretty_(self, p, cycle):
42 def _repr_pretty_(self, p, cycle):
43 if cycle:
43 if cycle:
44 p.text('MyList(...)')
44 p.text('MyList(...)')
45 else:
45 else:
46 with p.group(8, 'MyList([', '])'):
46 with p.group(8, 'MyList([', '])'):
47 for idx, item in enumerate(self):
47 for idx, item in enumerate(self):
48 if idx:
48 if idx:
49 p.text(',')
49 p.text(',')
50 p.breakable()
50 p.breakable()
51 p.pretty(item)
51 p.pretty(item)
52
52
53 The `cycle` parameter is `True` if pretty detected a cycle. You *have* to
53 The `cycle` parameter is `True` if pretty detected a cycle. You *have* to
54 react to that or the result is an infinite loop. `p.text()` just adds
54 react to that or the result is an infinite loop. `p.text()` just adds
55 non breaking text to the output, `p.breakable()` either adds a whitespace
55 non breaking text to the output, `p.breakable()` either adds a whitespace
56 or breaks here. If you pass it an argument it's used instead of the
56 or breaks here. If you pass it an argument it's used instead of the
57 default space. `p.pretty` prettyprints another object using the pretty print
57 default space. `p.pretty` prettyprints another object using the pretty print
58 method.
58 method.
59
59
60 The first parameter to the `group` function specifies the extra indentation
60 The first parameter to the `group` function specifies the extra indentation
61 of the next line. In this example the next item will either be on the same
61 of the next line. In this example the next item will either be on the same
62 line (if the items are short enough) or aligned with the right edge of the
62 line (if the items are short enough) or aligned with the right edge of the
63 opening bracket of `MyList`.
63 opening bracket of `MyList`.
64
64
65 If you just want to indent something you can use the group function
65 If you just want to indent something you can use the group function
66 without open / close parameters. Yu can also use this code::
66 without open / close parameters. Yu can also use this code::
67
67
68 with p.indent(2):
68 with p.indent(2):
69 ...
69 ...
70
70
71 Inheritance diagram:
71 Inheritance diagram:
72
72
73 .. inheritance-diagram:: IPython.lib.pretty
73 .. inheritance-diagram:: IPython.lib.pretty
74 :parts: 3
74 :parts: 3
75
75
76 :copyright: 2007 by Armin Ronacher.
76 :copyright: 2007 by Armin Ronacher.
77 Portions (c) 2009 by Robert Kern.
77 Portions (c) 2009 by Robert Kern.
78 :license: BSD License.
78 :license: BSD License.
79 """
79 """
80 from __future__ import print_function
80 from __future__ import print_function
81 from contextlib import contextmanager
81 from contextlib import contextmanager
82 import sys
82 import sys
83 import types
83 import types
84 import re
84 import re
85 import datetime
85 import datetime
86 from collections import deque
86 from collections import deque
87
87
88 from IPython.utils.py3compat import PY3, cast_unicode
88 from IPython.utils.py3compat import PY3, cast_unicode
89 from IPython.utils.encoding import get_stream_enc
89 from IPython.utils.encoding import get_stream_enc
90
90
91 from io import StringIO
91 from io import StringIO
92
92
93
93
94 __all__ = ['pretty', 'pprint', 'PrettyPrinter', 'RepresentationPrinter',
94 __all__ = ['pretty', 'pprint', 'PrettyPrinter', 'RepresentationPrinter',
95 'for_type', 'for_type_by_name']
95 'for_type', 'for_type_by_name']
96
96
97
97
98 MAX_SEQ_LENGTH = 1000
98 MAX_SEQ_LENGTH = 1000
99 _re_pattern_type = type(re.compile(''))
99 _re_pattern_type = type(re.compile(''))
100
100
101 def _safe_getattr(obj, attr, default=None):
101 def _safe_getattr(obj, attr, default=None):
102 """Safe version of getattr.
102 """Safe version of getattr.
103
103
104 Same as getattr, but will return ``default`` on any Exception,
104 Same as getattr, but will return ``default`` on any Exception,
105 rather than raising.
105 rather than raising.
106 """
106 """
107 try:
107 try:
108 return getattr(obj, attr, default)
108 return getattr(obj, attr, default)
109 except Exception:
109 except Exception:
110 return default
110 return default
111
111
112 if PY3:
112 if PY3:
113 CUnicodeIO = StringIO
113 CUnicodeIO = StringIO
114 else:
114 else:
115 class CUnicodeIO(StringIO):
115 class CUnicodeIO(StringIO):
116 """StringIO that casts str to unicode on Python 2"""
116 """StringIO that casts str to unicode on Python 2"""
117 def write(self, text):
117 def write(self, text):
118 return super(CUnicodeIO, self).write(
118 return super(CUnicodeIO, self).write(
119 cast_unicode(text, encoding=get_stream_enc(sys.stdout)))
119 cast_unicode(text, encoding=get_stream_enc(sys.stdout)))
120
120
121
121
122 def pretty(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
122 def pretty(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
123 """
123 """
124 Pretty print the object's representation.
124 Pretty print the object's representation.
125 """
125 """
126 stream = CUnicodeIO()
126 stream = CUnicodeIO()
127 printer = RepresentationPrinter(stream, verbose, max_width, newline, max_seq_length)
127 printer = RepresentationPrinter(stream, verbose, max_width, newline, max_seq_length)
128 printer.pretty(obj)
128 printer.pretty(obj)
129 printer.flush()
129 printer.flush()
130 return stream.getvalue()
130 return stream.getvalue()
131
131
132
132
133 def pprint(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
133 def pprint(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
134 """
134 """
135 Like `pretty` but print to stdout.
135 Like `pretty` but print to stdout.
136 """
136 """
137 printer = RepresentationPrinter(sys.stdout, verbose, max_width, newline, max_seq_length)
137 printer = RepresentationPrinter(sys.stdout, verbose, max_width, newline, max_seq_length)
138 printer.pretty(obj)
138 printer.pretty(obj)
139 printer.flush()
139 printer.flush()
140 sys.stdout.write(newline)
140 sys.stdout.write(newline)
141 sys.stdout.flush()
141 sys.stdout.flush()
142
142
143 class _PrettyPrinterBase(object):
143 class _PrettyPrinterBase(object):
144
144
145 @contextmanager
145 @contextmanager
146 def indent(self, indent):
146 def indent(self, indent):
147 """with statement support for indenting/dedenting."""
147 """with statement support for indenting/dedenting."""
148 self.indentation += indent
148 self.indentation += indent
149 try:
149 try:
150 yield
150 yield
151 finally:
151 finally:
152 self.indentation -= indent
152 self.indentation -= indent
153
153
154 @contextmanager
154 @contextmanager
155 def group(self, indent=0, open='', close=''):
155 def group(self, indent=0, open='', close=''):
156 """like begin_group / end_group but for the with statement."""
156 """like begin_group / end_group but for the with statement."""
157 self.begin_group(indent, open)
157 self.begin_group(indent, open)
158 try:
158 try:
159 yield
159 yield
160 finally:
160 finally:
161 self.end_group(indent, close)
161 self.end_group(indent, close)
162
162
163 class PrettyPrinter(_PrettyPrinterBase):
163 class PrettyPrinter(_PrettyPrinterBase):
164 """
164 """
165 Baseclass for the `RepresentationPrinter` prettyprinter that is used to
165 Baseclass for the `RepresentationPrinter` prettyprinter that is used to
166 generate pretty reprs of objects. Contrary to the `RepresentationPrinter`
166 generate pretty reprs of objects. Contrary to the `RepresentationPrinter`
167 this printer knows nothing about the default pprinters or the `_repr_pretty_`
167 this printer knows nothing about the default pprinters or the `_repr_pretty_`
168 callback method.
168 callback method.
169 """
169 """
170
170
171 def __init__(self, output, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
171 def __init__(self, output, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
172 self.output = output
172 self.output = output
173 self.max_width = max_width
173 self.max_width = max_width
174 self.newline = newline
174 self.newline = newline
175 self.max_seq_length = max_seq_length
175 self.max_seq_length = max_seq_length
176 self.output_width = 0
176 self.output_width = 0
177 self.buffer_width = 0
177 self.buffer_width = 0
178 self.buffer = deque()
178 self.buffer = deque()
179
179
180 root_group = Group(0)
180 root_group = Group(0)
181 self.group_stack = [root_group]
181 self.group_stack = [root_group]
182 self.group_queue = GroupQueue(root_group)
182 self.group_queue = GroupQueue(root_group)
183 self.indentation = 0
183 self.indentation = 0
184
184
185 def _break_outer_groups(self):
185 def _break_outer_groups(self):
186 while self.max_width < self.output_width + self.buffer_width:
186 while self.max_width < self.output_width + self.buffer_width:
187 group = self.group_queue.deq()
187 group = self.group_queue.deq()
188 if not group:
188 if not group:
189 return
189 return
190 while group.breakables:
190 while group.breakables:
191 x = self.buffer.popleft()
191 x = self.buffer.popleft()
192 self.output_width = x.output(self.output, self.output_width)
192 self.output_width = x.output(self.output, self.output_width)
193 self.buffer_width -= x.width
193 self.buffer_width -= x.width
194 while self.buffer and isinstance(self.buffer[0], Text):
194 while self.buffer and isinstance(self.buffer[0], Text):
195 x = self.buffer.popleft()
195 x = self.buffer.popleft()
196 self.output_width = x.output(self.output, self.output_width)
196 self.output_width = x.output(self.output, self.output_width)
197 self.buffer_width -= x.width
197 self.buffer_width -= x.width
198
198
199 def text(self, obj):
199 def text(self, obj):
200 """Add literal text to the output."""
200 """Add literal text to the output."""
201 width = len(obj)
201 width = len(obj)
202 if self.buffer:
202 if self.buffer:
203 text = self.buffer[-1]
203 text = self.buffer[-1]
204 if not isinstance(text, Text):
204 if not isinstance(text, Text):
205 text = Text()
205 text = Text()
206 self.buffer.append(text)
206 self.buffer.append(text)
207 text.add(obj, width)
207 text.add(obj, width)
208 self.buffer_width += width
208 self.buffer_width += width
209 self._break_outer_groups()
209 self._break_outer_groups()
210 else:
210 else:
211 self.output.write(obj)
211 self.output.write(obj)
212 self.output_width += width
212 self.output_width += width
213
213
214 def breakable(self, sep=' '):
214 def breakable(self, sep=' '):
215 """
215 """
216 Add a breakable separator to the output. This does not mean that it
216 Add a breakable separator to the output. This does not mean that it
217 will automatically break here. If no breaking on this position takes
217 will automatically break here. If no breaking on this position takes
218 place the `sep` is inserted which default to one space.
218 place the `sep` is inserted which default to one space.
219 """
219 """
220 width = len(sep)
220 width = len(sep)
221 group = self.group_stack[-1]
221 group = self.group_stack[-1]
222 if group.want_break:
222 if group.want_break:
223 self.flush()
223 self.flush()
224 self.output.write(self.newline)
224 self.output.write(self.newline)
225 self.output.write(' ' * self.indentation)
225 self.output.write(' ' * self.indentation)
226 self.output_width = self.indentation
226 self.output_width = self.indentation
227 self.buffer_width = 0
227 self.buffer_width = 0
228 else:
228 else:
229 self.buffer.append(Breakable(sep, width, self))
229 self.buffer.append(Breakable(sep, width, self))
230 self.buffer_width += width
230 self.buffer_width += width
231 self._break_outer_groups()
231 self._break_outer_groups()
232
232
233 def break_(self):
233 def break_(self):
234 """
234 """
235 Explicitly insert a newline into the output, maintaining correct indentation.
235 Explicitly insert a newline into the output, maintaining correct indentation.
236 """
236 """
237 self.flush()
237 self.flush()
238 self.output.write(self.newline)
238 self.output.write(self.newline)
239 self.output.write(' ' * self.indentation)
239 self.output.write(' ' * self.indentation)
240 self.output_width = self.indentation
240 self.output_width = self.indentation
241 self.buffer_width = 0
241 self.buffer_width = 0
242
242
243
243
244 def begin_group(self, indent=0, open=''):
244 def begin_group(self, indent=0, open=''):
245 """
245 """
246 Begin a group. If you want support for python < 2.5 which doesn't has
246 Begin a group. If you want support for python < 2.5 which doesn't has
247 the with statement this is the preferred way:
247 the with statement this is the preferred way:
248
248
249 p.begin_group(1, '{')
249 p.begin_group(1, '{')
250 ...
250 ...
251 p.end_group(1, '}')
251 p.end_group(1, '}')
252
252
253 The python 2.5 expression would be this:
253 The python 2.5 expression would be this:
254
254
255 with p.group(1, '{', '}'):
255 with p.group(1, '{', '}'):
256 ...
256 ...
257
257
258 The first parameter specifies the indentation for the next line (usually
258 The first parameter specifies the indentation for the next line (usually
259 the width of the opening text), the second the opening text. All
259 the width of the opening text), the second the opening text. All
260 parameters are optional.
260 parameters are optional.
261 """
261 """
262 if open:
262 if open:
263 self.text(open)
263 self.text(open)
264 group = Group(self.group_stack[-1].depth + 1)
264 group = Group(self.group_stack[-1].depth + 1)
265 self.group_stack.append(group)
265 self.group_stack.append(group)
266 self.group_queue.enq(group)
266 self.group_queue.enq(group)
267 self.indentation += indent
267 self.indentation += indent
268
268
269 def _enumerate(self, seq):
269 def _enumerate(self, seq):
270 """like enumerate, but with an upper limit on the number of items"""
270 """like enumerate, but with an upper limit on the number of items"""
271 for idx, x in enumerate(seq):
271 for idx, x in enumerate(seq):
272 if self.max_seq_length and idx >= self.max_seq_length:
272 if self.max_seq_length and idx >= self.max_seq_length:
273 self.text(',')
273 self.text(',')
274 self.breakable()
274 self.breakable()
275 self.text('...')
275 self.text('...')
276 raise StopIteration
276 raise StopIteration
277 yield idx, x
277 yield idx, x
278
278
279 def end_group(self, dedent=0, close=''):
279 def end_group(self, dedent=0, close=''):
280 """End a group. See `begin_group` for more details."""
280 """End a group. See `begin_group` for more details."""
281 self.indentation -= dedent
281 self.indentation -= dedent
282 group = self.group_stack.pop()
282 group = self.group_stack.pop()
283 if not group.breakables:
283 if not group.breakables:
284 self.group_queue.remove(group)
284 self.group_queue.remove(group)
285 if close:
285 if close:
286 self.text(close)
286 self.text(close)
287
287
288 def flush(self):
288 def flush(self):
289 """Flush data that is left in the buffer."""
289 """Flush data that is left in the buffer."""
290 for data in self.buffer:
290 for data in self.buffer:
291 self.output_width += data.output(self.output, self.output_width)
291 self.output_width += data.output(self.output, self.output_width)
292 self.buffer.clear()
292 self.buffer.clear()
293 self.buffer_width = 0
293 self.buffer_width = 0
294
294
295
295
296 def _get_mro(obj_class):
296 def _get_mro(obj_class):
297 """ Get a reasonable method resolution order of a class and its superclasses
297 """ Get a reasonable method resolution order of a class and its superclasses
298 for both old-style and new-style classes.
298 for both old-style and new-style classes.
299 """
299 """
300 if not hasattr(obj_class, '__mro__'):
300 if not hasattr(obj_class, '__mro__'):
301 # Old-style class. Mix in object to make a fake new-style class.
301 # Old-style class. Mix in object to make a fake new-style class.
302 try:
302 try:
303 obj_class = type(obj_class.__name__, (obj_class, object), {})
303 obj_class = type(obj_class.__name__, (obj_class, object), {})
304 except TypeError:
304 except TypeError:
305 # Old-style extension type that does not descend from object.
305 # Old-style extension type that does not descend from object.
306 # FIXME: try to construct a more thorough MRO.
306 # FIXME: try to construct a more thorough MRO.
307 mro = [obj_class]
307 mro = [obj_class]
308 else:
308 else:
309 mro = obj_class.__mro__[1:-1]
309 mro = obj_class.__mro__[1:-1]
310 else:
310 else:
311 mro = obj_class.__mro__
311 mro = obj_class.__mro__
312 return mro
312 return mro
313
313
314
314
315 class RepresentationPrinter(PrettyPrinter):
315 class RepresentationPrinter(PrettyPrinter):
316 """
316 """
317 Special pretty printer that has a `pretty` method that calls the pretty
317 Special pretty printer that has a `pretty` method that calls the pretty
318 printer for a python object.
318 printer for a python object.
319
319
320 This class stores processing data on `self` so you must *never* use
320 This class stores processing data on `self` so you must *never* use
321 this class in a threaded environment. Always lock it or reinstanciate
321 this class in a threaded environment. Always lock it or reinstanciate
322 it.
322 it.
323
323
324 Instances also have a verbose flag callbacks can access to control their
324 Instances also have a verbose flag callbacks can access to control their
325 output. For example the default instance repr prints all attributes and
325 output. For example the default instance repr prints all attributes and
326 methods that are not prefixed by an underscore if the printer is in
326 methods that are not prefixed by an underscore if the printer is in
327 verbose mode.
327 verbose mode.
328 """
328 """
329
329
330 def __init__(self, output, verbose=False, max_width=79, newline='\n',
330 def __init__(self, output, verbose=False, max_width=79, newline='\n',
331 singleton_pprinters=None, type_pprinters=None, deferred_pprinters=None,
331 singleton_pprinters=None, type_pprinters=None, deferred_pprinters=None,
332 max_seq_length=MAX_SEQ_LENGTH):
332 max_seq_length=MAX_SEQ_LENGTH):
333
333
334 PrettyPrinter.__init__(self, output, max_width, newline, max_seq_length=max_seq_length)
334 PrettyPrinter.__init__(self, output, max_width, newline, max_seq_length=max_seq_length)
335 self.verbose = verbose
335 self.verbose = verbose
336 self.stack = []
336 self.stack = []
337 if singleton_pprinters is None:
337 if singleton_pprinters is None:
338 singleton_pprinters = _singleton_pprinters.copy()
338 singleton_pprinters = _singleton_pprinters.copy()
339 self.singleton_pprinters = singleton_pprinters
339 self.singleton_pprinters = singleton_pprinters
340 if type_pprinters is None:
340 if type_pprinters is None:
341 type_pprinters = _type_pprinters.copy()
341 type_pprinters = _type_pprinters.copy()
342 self.type_pprinters = type_pprinters
342 self.type_pprinters = type_pprinters
343 if deferred_pprinters is None:
343 if deferred_pprinters is None:
344 deferred_pprinters = _deferred_type_pprinters.copy()
344 deferred_pprinters = _deferred_type_pprinters.copy()
345 self.deferred_pprinters = deferred_pprinters
345 self.deferred_pprinters = deferred_pprinters
346
346
347 def pretty(self, obj):
347 def pretty(self, obj):
348 """Pretty print the given object."""
348 """Pretty print the given object."""
349 obj_id = id(obj)
349 obj_id = id(obj)
350 cycle = obj_id in self.stack
350 cycle = obj_id in self.stack
351 self.stack.append(obj_id)
351 self.stack.append(obj_id)
352 self.begin_group()
352 self.begin_group()
353 try:
353 try:
354 obj_class = _safe_getattr(obj, '__class__', None) or type(obj)
354 obj_class = _safe_getattr(obj, '__class__', None) or type(obj)
355 # First try to find registered singleton printers for the type.
355 # First try to find registered singleton printers for the type.
356 try:
356 try:
357 printer = self.singleton_pprinters[obj_id]
357 printer = self.singleton_pprinters[obj_id]
358 except (TypeError, KeyError):
358 except (TypeError, KeyError):
359 pass
359 pass
360 else:
360 else:
361 return printer(obj, self, cycle)
361 return printer(obj, self, cycle)
362 # Next walk the mro and check for either:
362 # Next walk the mro and check for either:
363 # 1) a registered printer
363 # 1) a registered printer
364 # 2) a _repr_pretty_ method
364 # 2) a _repr_pretty_ method
365 for cls in _get_mro(obj_class):
365 for cls in _get_mro(obj_class):
366 if cls in self.type_pprinters:
366 if cls in self.type_pprinters:
367 # printer registered in self.type_pprinters
367 # printer registered in self.type_pprinters
368 return self.type_pprinters[cls](obj, self, cycle)
368 return self.type_pprinters[cls](obj, self, cycle)
369 else:
369 else:
370 # deferred printer
370 # deferred printer
371 printer = self._in_deferred_types(cls)
371 printer = self._in_deferred_types(cls)
372 if printer is not None:
372 if printer is not None:
373 return printer(obj, self, cycle)
373 return printer(obj, self, cycle)
374 else:
374 else:
375 # Finally look for special method names.
375 # Finally look for special method names.
376 # Some objects automatically create any requested
376 # Some objects automatically create any requested
377 # attribute. Try to ignore most of them by checking for
377 # attribute. Try to ignore most of them by checking for
378 # callability.
378 # callability.
379 if '_repr_pretty_' in cls.__dict__:
379 if '_repr_pretty_' in cls.__dict__:
380 meth = cls._repr_pretty_
380 meth = cls._repr_pretty_
381 if callable(meth):
381 if callable(meth):
382 return meth(obj, self, cycle)
382 return meth(obj, self, cycle)
383 return _default_pprint(obj, self, cycle)
383 return _default_pprint(obj, self, cycle)
384 finally:
384 finally:
385 self.end_group()
385 self.end_group()
386 self.stack.pop()
386 self.stack.pop()
387
387
388 def _in_deferred_types(self, cls):
388 def _in_deferred_types(self, cls):
389 """
389 """
390 Check if the given class is specified in the deferred type registry.
390 Check if the given class is specified in the deferred type registry.
391
391
392 Returns the printer from the registry if it exists, and None if the
392 Returns the printer from the registry if it exists, and None if the
393 class is not in the registry. Successful matches will be moved to the
393 class is not in the registry. Successful matches will be moved to the
394 regular type registry for future use.
394 regular type registry for future use.
395 """
395 """
396 mod = _safe_getattr(cls, '__module__', None)
396 mod = _safe_getattr(cls, '__module__', None)
397 name = _safe_getattr(cls, '__name__', None)
397 name = _safe_getattr(cls, '__name__', None)
398 key = (mod, name)
398 key = (mod, name)
399 printer = None
399 printer = None
400 if key in self.deferred_pprinters:
400 if key in self.deferred_pprinters:
401 # Move the printer over to the regular registry.
401 # Move the printer over to the regular registry.
402 printer = self.deferred_pprinters.pop(key)
402 printer = self.deferred_pprinters.pop(key)
403 self.type_pprinters[cls] = printer
403 self.type_pprinters[cls] = printer
404 return printer
404 return printer
405
405
406
406
407 class Printable(object):
407 class Printable(object):
408
408
409 def output(self, stream, output_width):
409 def output(self, stream, output_width):
410 return output_width
410 return output_width
411
411
412
412
413 class Text(Printable):
413 class Text(Printable):
414
414
415 def __init__(self):
415 def __init__(self):
416 self.objs = []
416 self.objs = []
417 self.width = 0
417 self.width = 0
418
418
419 def output(self, stream, output_width):
419 def output(self, stream, output_width):
420 for obj in self.objs:
420 for obj in self.objs:
421 stream.write(obj)
421 stream.write(obj)
422 return output_width + self.width
422 return output_width + self.width
423
423
424 def add(self, obj, width):
424 def add(self, obj, width):
425 self.objs.append(obj)
425 self.objs.append(obj)
426 self.width += width
426 self.width += width
427
427
428
428
429 class Breakable(Printable):
429 class Breakable(Printable):
430
430
431 def __init__(self, seq, width, pretty):
431 def __init__(self, seq, width, pretty):
432 self.obj = seq
432 self.obj = seq
433 self.width = width
433 self.width = width
434 self.pretty = pretty
434 self.pretty = pretty
435 self.indentation = pretty.indentation
435 self.indentation = pretty.indentation
436 self.group = pretty.group_stack[-1]
436 self.group = pretty.group_stack[-1]
437 self.group.breakables.append(self)
437 self.group.breakables.append(self)
438
438
439 def output(self, stream, output_width):
439 def output(self, stream, output_width):
440 self.group.breakables.popleft()
440 self.group.breakables.popleft()
441 if self.group.want_break:
441 if self.group.want_break:
442 stream.write(self.pretty.newline)
442 stream.write(self.pretty.newline)
443 stream.write(' ' * self.indentation)
443 stream.write(' ' * self.indentation)
444 return self.indentation
444 return self.indentation
445 if not self.group.breakables:
445 if not self.group.breakables:
446 self.pretty.group_queue.remove(self.group)
446 self.pretty.group_queue.remove(self.group)
447 stream.write(self.obj)
447 stream.write(self.obj)
448 return output_width + self.width
448 return output_width + self.width
449
449
450
450
451 class Group(Printable):
451 class Group(Printable):
452
452
453 def __init__(self, depth):
453 def __init__(self, depth):
454 self.depth = depth
454 self.depth = depth
455 self.breakables = deque()
455 self.breakables = deque()
456 self.want_break = False
456 self.want_break = False
457
457
458
458
459 class GroupQueue(object):
459 class GroupQueue(object):
460
460
461 def __init__(self, *groups):
461 def __init__(self, *groups):
462 self.queue = []
462 self.queue = []
463 for group in groups:
463 for group in groups:
464 self.enq(group)
464 self.enq(group)
465
465
466 def enq(self, group):
466 def enq(self, group):
467 depth = group.depth
467 depth = group.depth
468 while depth > len(self.queue) - 1:
468 while depth > len(self.queue) - 1:
469 self.queue.append([])
469 self.queue.append([])
470 self.queue[depth].append(group)
470 self.queue[depth].append(group)
471
471
472 def deq(self):
472 def deq(self):
473 for stack in self.queue:
473 for stack in self.queue:
474 for idx, group in enumerate(reversed(stack)):
474 for idx, group in enumerate(reversed(stack)):
475 if group.breakables:
475 if group.breakables:
476 del stack[idx]
476 del stack[idx]
477 group.want_break = True
477 group.want_break = True
478 return group
478 return group
479 for group in stack:
479 for group in stack:
480 group.want_break = True
480 group.want_break = True
481 del stack[:]
481 del stack[:]
482
482
483 def remove(self, group):
483 def remove(self, group):
484 try:
484 try:
485 self.queue[group.depth].remove(group)
485 self.queue[group.depth].remove(group)
486 except ValueError:
486 except ValueError:
487 pass
487 pass
488
488
489 try:
489 try:
490 _baseclass_reprs = (object.__repr__, types.InstanceType.__repr__)
490 _baseclass_reprs = (object.__repr__, types.InstanceType.__repr__)
491 except AttributeError: # Python 3
491 except AttributeError: # Python 3
492 _baseclass_reprs = (object.__repr__,)
492 _baseclass_reprs = (object.__repr__,)
493
493
494
494
495 def _default_pprint(obj, p, cycle):
495 def _default_pprint(obj, p, cycle):
496 """
496 """
497 The default print function. Used if an object does not provide one and
497 The default print function. Used if an object does not provide one and
498 it's none of the builtin objects.
498 it's none of the builtin objects.
499 """
499 """
500 klass = _safe_getattr(obj, '__class__', None) or type(obj)
500 klass = _safe_getattr(obj, '__class__', None) or type(obj)
501 if _safe_getattr(klass, '__repr__', None) not in _baseclass_reprs:
501 if _safe_getattr(klass, '__repr__', None) not in _baseclass_reprs:
502 # A user-provided repr. Find newlines and replace them with p.break_()
502 # A user-provided repr. Find newlines and replace them with p.break_()
503 _repr_pprint(obj, p, cycle)
503 _repr_pprint(obj, p, cycle)
504 return
504 return
505 p.begin_group(1, '<')
505 p.begin_group(1, '<')
506 p.pretty(klass)
506 p.pretty(klass)
507 p.text(' at 0x%x' % id(obj))
507 p.text(' at 0x%x' % id(obj))
508 if cycle:
508 if cycle:
509 p.text(' ...')
509 p.text(' ...')
510 elif p.verbose:
510 elif p.verbose:
511 first = True
511 first = True
512 for key in dir(obj):
512 for key in dir(obj):
513 if not key.startswith('_'):
513 if not key.startswith('_'):
514 try:
514 try:
515 value = getattr(obj, key)
515 value = getattr(obj, key)
516 except AttributeError:
516 except AttributeError:
517 continue
517 continue
518 if isinstance(value, types.MethodType):
518 if isinstance(value, types.MethodType):
519 continue
519 continue
520 if not first:
520 if not first:
521 p.text(',')
521 p.text(',')
522 p.breakable()
522 p.breakable()
523 p.text(key)
523 p.text(key)
524 p.text('=')
524 p.text('=')
525 step = len(key) + 1
525 step = len(key) + 1
526 p.indentation += step
526 p.indentation += step
527 p.pretty(value)
527 p.pretty(value)
528 p.indentation -= step
528 p.indentation -= step
529 first = False
529 first = False
530 p.end_group(1, '>')
530 p.end_group(1, '>')
531
531
532
532
533 def _seq_pprinter_factory(start, end, basetype):
533 def _seq_pprinter_factory(start, end, basetype):
534 """
534 """
535 Factory that returns a pprint function useful for sequences. Used by
535 Factory that returns a pprint function useful for sequences. Used by
536 the default pprint for tuples, dicts, and lists.
536 the default pprint for tuples, dicts, and lists.
537 """
537 """
538 def inner(obj, p, cycle):
538 def inner(obj, p, cycle):
539 typ = type(obj)
539 typ = type(obj)
540 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
540 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
541 # If the subclass provides its own repr, use it instead.
541 # If the subclass provides its own repr, use it instead.
542 return p.text(typ.__repr__(obj))
542 return p.text(typ.__repr__(obj))
543
543
544 if cycle:
544 if cycle:
545 return p.text(start + '...' + end)
545 return p.text(start + '...' + end)
546 step = len(start)
546 step = len(start)
547 p.begin_group(step, start)
547 p.begin_group(step, start)
548 for idx, x in p._enumerate(obj):
548 for idx, x in p._enumerate(obj):
549 if idx:
549 if idx:
550 p.text(',')
550 p.text(',')
551 p.breakable()
551 p.breakable()
552 p.pretty(x)
552 p.pretty(x)
553 if len(obj) == 1 and type(obj) is tuple:
553 if len(obj) == 1 and type(obj) is tuple:
554 # Special case for 1-item tuples.
554 # Special case for 1-item tuples.
555 p.text(',')
555 p.text(',')
556 p.end_group(step, end)
556 p.end_group(step, end)
557 return inner
557 return inner
558
558
559
559
560 def _set_pprinter_factory(start, end, basetype):
560 def _set_pprinter_factory(start, end, basetype):
561 """
561 """
562 Factory that returns a pprint function useful for sets and frozensets.
562 Factory that returns a pprint function useful for sets and frozensets.
563 """
563 """
564 def inner(obj, p, cycle):
564 def inner(obj, p, cycle):
565 typ = type(obj)
565 typ = type(obj)
566 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
566 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
567 # If the subclass provides its own repr, use it instead.
567 # If the subclass provides its own repr, use it instead.
568 return p.text(typ.__repr__(obj))
568 return p.text(typ.__repr__(obj))
569
569
570 if cycle:
570 if cycle:
571 return p.text(start + '...' + end)
571 return p.text(start + '...' + end)
572 if len(obj) == 0:
572 if len(obj) == 0:
573 # Special case.
573 # Special case.
574 p.text(basetype.__name__ + '()')
574 p.text(basetype.__name__ + '()')
575 else:
575 else:
576 step = len(start)
576 step = len(start)
577 p.begin_group(step, start)
577 p.begin_group(step, start)
578 # Like dictionary keys, we will try to sort the items if there aren't too many
578 # Like dictionary keys, we will try to sort the items if there aren't too many
579 items = obj
579 items = obj
580 if not (p.max_seq_length and len(obj) >= p.max_seq_length):
580 if not (p.max_seq_length and len(obj) >= p.max_seq_length):
581 try:
581 try:
582 items = sorted(obj)
582 items = sorted(obj)
583 except Exception:
583 except Exception:
584 # Sometimes the items don't sort.
584 # Sometimes the items don't sort.
585 pass
585 pass
586 for idx, x in p._enumerate(items):
586 for idx, x in p._enumerate(items):
587 if idx:
587 if idx:
588 p.text(',')
588 p.text(',')
589 p.breakable()
589 p.breakable()
590 p.pretty(x)
590 p.pretty(x)
591 p.end_group(step, end)
591 p.end_group(step, end)
592 return inner
592 return inner
593
593
594
594
595 def _dict_pprinter_factory(start, end, basetype=None):
595 def _dict_pprinter_factory(start, end, basetype=None):
596 """
596 """
597 Factory that returns a pprint function used by the default pprint of
597 Factory that returns a pprint function used by the default pprint of
598 dicts and dict proxies.
598 dicts and dict proxies.
599 """
599 """
600 def inner(obj, p, cycle):
600 def inner(obj, p, cycle):
601 typ = type(obj)
601 typ = type(obj)
602 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
602 if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:
603 # If the subclass provides its own repr, use it instead.
603 # If the subclass provides its own repr, use it instead.
604 return p.text(typ.__repr__(obj))
604 return p.text(typ.__repr__(obj))
605
605
606 if cycle:
606 if cycle:
607 return p.text('{...}')
607 return p.text('{...}')
608 p.begin_group(1, start)
608 p.begin_group(1, start)
609 keys = obj.keys()
609 keys = obj.keys()
610 # if dict isn't large enough to be truncated, sort keys before displaying
610 # if dict isn't large enough to be truncated, sort keys before displaying
611 if not (p.max_seq_length and len(obj) >= p.max_seq_length):
611 if not (p.max_seq_length and len(obj) >= p.max_seq_length):
612 try:
612 try:
613 keys = sorted(keys)
613 keys = sorted(keys)
614 except Exception:
614 except Exception:
615 # Sometimes the keys don't sort.
615 # Sometimes the keys don't sort.
616 pass
616 pass
617 for idx, key in p._enumerate(keys):
617 for idx, key in p._enumerate(keys):
618 if idx:
618 if idx:
619 p.text(',')
619 p.text(',')
620 p.breakable()
620 p.breakable()
621 p.pretty(key)
621 p.pretty(key)
622 p.text(': ')
622 p.text(': ')
623 p.pretty(obj[key])
623 p.pretty(obj[key])
624 p.end_group(1, end)
624 p.end_group(1, end)
625 return inner
625 return inner
626
626
627
627
628 def _super_pprint(obj, p, cycle):
628 def _super_pprint(obj, p, cycle):
629 """The pprint for the super type."""
629 """The pprint for the super type."""
630 p.begin_group(8, '<super: ')
630 p.begin_group(8, '<super: ')
631 p.pretty(obj.__thisclass__)
631 p.pretty(obj.__thisclass__)
632 p.text(',')
632 p.text(',')
633 p.breakable()
633 p.breakable()
634 p.pretty(obj.__self__)
634 p.pretty(obj.__self__)
635 p.end_group(8, '>')
635 p.end_group(8, '>')
636
636
637
637
638 def _re_pattern_pprint(obj, p, cycle):
638 def _re_pattern_pprint(obj, p, cycle):
639 """The pprint function for regular expression patterns."""
639 """The pprint function for regular expression patterns."""
640 p.text('re.compile(')
640 p.text('re.compile(')
641 pattern = repr(obj.pattern)
641 pattern = repr(obj.pattern)
642 if pattern[:1] in 'uU':
642 if pattern[:1] in 'uU':
643 pattern = pattern[1:]
643 pattern = pattern[1:]
644 prefix = 'ur'
644 prefix = 'ur'
645 else:
645 else:
646 prefix = 'r'
646 prefix = 'r'
647 pattern = prefix + pattern.replace('\\\\', '\\')
647 pattern = prefix + pattern.replace('\\\\', '\\')
648 p.text(pattern)
648 p.text(pattern)
649 if obj.flags:
649 if obj.flags:
650 p.text(',')
650 p.text(',')
651 p.breakable()
651 p.breakable()
652 done_one = False
652 done_one = False
653 for flag in ('TEMPLATE', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL',
653 for flag in ('TEMPLATE', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL',
654 'UNICODE', 'VERBOSE', 'DEBUG'):
654 'UNICODE', 'VERBOSE', 'DEBUG'):
655 if obj.flags & getattr(re, flag):
655 if obj.flags & getattr(re, flag):
656 if done_one:
656 if done_one:
657 p.text('|')
657 p.text('|')
658 p.text('re.' + flag)
658 p.text('re.' + flag)
659 done_one = True
659 done_one = True
660 p.text(')')
660 p.text(')')
661
661
662
662
663 def _type_pprint(obj, p, cycle):
663 def _type_pprint(obj, p, cycle):
664 """The pprint for classes and types."""
664 """The pprint for classes and types."""
665 # Heap allocated types might not have the module attribute,
665 # Heap allocated types might not have the module attribute,
666 # and others may set it to None.
666 # and others may set it to None.
667
667
668 # Checks for a __repr__ override in the metaclass
668 # Checks for a __repr__ override in the metaclass
669 if type(obj).__repr__ is not type.__repr__:
669 if type(obj).__repr__ is not type.__repr__:
670 _repr_pprint(obj, p, cycle)
670 _repr_pprint(obj, p, cycle)
671 return
671 return
672
672
673 mod = _safe_getattr(obj, '__module__', None)
673 mod = _safe_getattr(obj, '__module__', None)
674 name = _safe_getattr(obj, '__qualname__', obj.__name__)
674 name = _safe_getattr(obj, '__qualname__', obj.__name__)
675
675
676 if mod in (None, '__builtin__', 'builtins', 'exceptions'):
676 if mod in (None, '__builtin__', 'builtins', 'exceptions'):
677 p.text(name)
677 p.text(name)
678 else:
678 else:
679 p.text(mod + '.' + name)
679 p.text(mod + '.' + name)
680
680
681
681
682 def _repr_pprint(obj, p, cycle):
682 def _repr_pprint(obj, p, cycle):
683 """A pprint that just redirects to the normal repr function."""
683 """A pprint that just redirects to the normal repr function."""
684 # Find newlines and replace them with p.break_()
684 # Find newlines and replace them with p.break_()
685 output = repr(obj)
685 output = repr(obj)
686 for idx,output_line in enumerate(output.splitlines()):
686 for idx,output_line in enumerate(output.splitlines()):
687 if idx:
687 if idx:
688 p.break_()
688 p.break_()
689 p.text(output_line)
689 p.text(output_line)
690
690
691
691
692 def _function_pprint(obj, p, cycle):
692 def _function_pprint(obj, p, cycle):
693 """Base pprint for all functions and builtin functions."""
693 """Base pprint for all functions and builtin functions."""
694 name = _safe_getattr(obj, '__qualname__', obj.__name__)
694 name = _safe_getattr(obj, '__qualname__', obj.__name__)
695 mod = obj.__module__
695 mod = obj.__module__
696 if mod and mod not in ('__builtin__', 'builtins', 'exceptions'):
696 if mod and mod not in ('__builtin__', 'builtins', 'exceptions'):
697 name = mod + '.' + name
697 name = mod + '.' + name
698 p.text('<function %s>' % name)
698 p.text('<function %s>' % name)
699
699
700
700
701 def _exception_pprint(obj, p, cycle):
701 def _exception_pprint(obj, p, cycle):
702 """Base pprint for all exceptions."""
702 """Base pprint for all exceptions."""
703 name = getattr(obj.__class__, '__qualname__', obj.__class__.__name__)
703 name = getattr(obj.__class__, '__qualname__', obj.__class__.__name__)
704 if obj.__class__.__module__ not in ('exceptions', 'builtins'):
704 if obj.__class__.__module__ not in ('exceptions', 'builtins'):
705 name = '%s.%s' % (obj.__class__.__module__, name)
705 name = '%s.%s' % (obj.__class__.__module__, name)
706 step = len(name) + 1
706 step = len(name) + 1
707 p.begin_group(step, name + '(')
707 p.begin_group(step, name + '(')
708 for idx, arg in enumerate(getattr(obj, 'args', ())):
708 for idx, arg in enumerate(getattr(obj, 'args', ())):
709 if idx:
709 if idx:
710 p.text(',')
710 p.text(',')
711 p.breakable()
711 p.breakable()
712 p.pretty(arg)
712 p.pretty(arg)
713 p.end_group(step, ')')
713 p.end_group(step, ')')
714
714
715
715
716 #: the exception base
716 #: the exception base
717 try:
717 try:
718 _exception_base = BaseException
718 _exception_base = BaseException
719 except NameError:
719 except NameError:
720 _exception_base = Exception
720 _exception_base = Exception
721
721
722
722
723 #: printers for builtin types
723 #: printers for builtin types
724 _type_pprinters = {
724 _type_pprinters = {
725 int: _repr_pprint,
725 int: _repr_pprint,
726 float: _repr_pprint,
726 float: _repr_pprint,
727 str: _repr_pprint,
727 str: _repr_pprint,
728 tuple: _seq_pprinter_factory('(', ')', tuple),
728 tuple: _seq_pprinter_factory('(', ')', tuple),
729 list: _seq_pprinter_factory('[', ']', list),
729 list: _seq_pprinter_factory('[', ']', list),
730 dict: _dict_pprinter_factory('{', '}', dict),
730 dict: _dict_pprinter_factory('{', '}', dict),
731
731
732 set: _set_pprinter_factory('{', '}', set),
732 set: _set_pprinter_factory('{', '}', set),
733 frozenset: _set_pprinter_factory('frozenset({', '})', frozenset),
733 frozenset: _set_pprinter_factory('frozenset({', '})', frozenset),
734 super: _super_pprint,
734 super: _super_pprint,
735 _re_pattern_type: _re_pattern_pprint,
735 _re_pattern_type: _re_pattern_pprint,
736 type: _type_pprint,
736 type: _type_pprint,
737 types.FunctionType: _function_pprint,
737 types.FunctionType: _function_pprint,
738 types.BuiltinFunctionType: _function_pprint,
738 types.BuiltinFunctionType: _function_pprint,
739 types.MethodType: _repr_pprint,
739 types.MethodType: _repr_pprint,
740
740
741 datetime.datetime: _repr_pprint,
741 datetime.datetime: _repr_pprint,
742 datetime.timedelta: _repr_pprint,
742 datetime.timedelta: _repr_pprint,
743 _exception_base: _exception_pprint
743 _exception_base: _exception_pprint
744 }
744 }
745
745
746 try:
746 try:
747 _type_pprinters[types.DictProxyType] = _dict_pprinter_factory('<dictproxy {', '}>')
747 _type_pprinters[types.DictProxyType] = _dict_pprinter_factory('<dictproxy {', '}>')
748 _type_pprinters[types.ClassType] = _type_pprint
748 _type_pprinters[types.ClassType] = _type_pprint
749 _type_pprinters[types.SliceType] = _repr_pprint
749 _type_pprinters[types.SliceType] = _repr_pprint
750 except AttributeError: # Python 3
750 except AttributeError: # Python 3
751 _type_pprinters[slice] = _repr_pprint
751 _type_pprinters[slice] = _repr_pprint
752
752
753 try:
753 try:
754 _type_pprinters[xrange] = _repr_pprint
754 _type_pprinters[xrange] = _repr_pprint
755 _type_pprinters[long] = _repr_pprint
755 _type_pprinters[long] = _repr_pprint
756 _type_pprinters[unicode] = _repr_pprint
756 _type_pprinters[unicode] = _repr_pprint
757 except NameError:
757 except NameError:
758 _type_pprinters[range] = _repr_pprint
758 _type_pprinters[range] = _repr_pprint
759 _type_pprinters[bytes] = _repr_pprint
759 _type_pprinters[bytes] = _repr_pprint
760
760
761 #: printers for types specified by name
761 #: printers for types specified by name
762 _deferred_type_pprinters = {
762 _deferred_type_pprinters = {
763 }
763 }
764
764
765 def for_type(typ, func):
765 def for_type(typ, func):
766 """
766 """
767 Add a pretty printer for a given type.
767 Add a pretty printer for a given type.
768 """
768 """
769 oldfunc = _type_pprinters.get(typ, None)
769 oldfunc = _type_pprinters.get(typ, None)
770 if func is not None:
770 if func is not None:
771 # To support easy restoration of old pprinters, we need to ignore Nones.
771 # To support easy restoration of old pprinters, we need to ignore Nones.
772 _type_pprinters[typ] = func
772 _type_pprinters[typ] = func
773 return oldfunc
773 return oldfunc
774
774
775 def for_type_by_name(type_module, type_name, func):
775 def for_type_by_name(type_module, type_name, func):
776 """
776 """
777 Add a pretty printer for a type specified by the module and name of a type
777 Add a pretty printer for a type specified by the module and name of a type
778 rather than the type object itself.
778 rather than the type object itself.
779 """
779 """
780 key = (type_module, type_name)
780 key = (type_module, type_name)
781 oldfunc = _deferred_type_pprinters.get(key, None)
781 oldfunc = _deferred_type_pprinters.get(key, None)
782 if func is not None:
782 if func is not None:
783 # To support easy restoration of old pprinters, we need to ignore Nones.
783 # To support easy restoration of old pprinters, we need to ignore Nones.
784 _deferred_type_pprinters[key] = func
784 _deferred_type_pprinters[key] = func
785 return oldfunc
785 return oldfunc
786
786
787
787
788 #: printers for the default singletons
788 #: printers for the default singletons
789 _singleton_pprinters = dict.fromkeys(map(id, [None, True, False, Ellipsis,
789 _singleton_pprinters = dict.fromkeys(map(id, [None, True, False, Ellipsis,
790 NotImplemented]), _repr_pprint)
790 NotImplemented]), _repr_pprint)
791
791
792
792
793 def _defaultdict_pprint(obj, p, cycle):
793 def _defaultdict_pprint(obj, p, cycle):
794 name = 'defaultdict'
794 name = 'defaultdict'
795 with p.group(len(name) + 1, name + '(', ')'):
795 with p.group(len(name) + 1, name + '(', ')'):
796 if cycle:
796 if cycle:
797 p.text('...')
797 p.text('...')
798 else:
798 else:
799 p.pretty(obj.default_factory)
799 p.pretty(obj.default_factory)
800 p.text(',')
800 p.text(',')
801 p.breakable()
801 p.breakable()
802 p.pretty(dict(obj))
802 p.pretty(dict(obj))
803
803
804 def _ordereddict_pprint(obj, p, cycle):
804 def _ordereddict_pprint(obj, p, cycle):
805 name = 'OrderedDict'
805 name = 'OrderedDict'
806 with p.group(len(name) + 1, name + '(', ')'):
806 with p.group(len(name) + 1, name + '(', ')'):
807 if cycle:
807 if cycle:
808 p.text('...')
808 p.text('...')
809 elif len(obj):
809 elif len(obj):
810 p.pretty(list(obj.items()))
810 p.pretty(list(obj.items()))
811
811
812 def _deque_pprint(obj, p, cycle):
812 def _deque_pprint(obj, p, cycle):
813 name = 'deque'
813 name = 'deque'
814 with p.group(len(name) + 1, name + '(', ')'):
814 with p.group(len(name) + 1, name + '(', ')'):
815 if cycle:
815 if cycle:
816 p.text('...')
816 p.text('...')
817 else:
817 else:
818 p.pretty(list(obj))
818 p.pretty(list(obj))
819
819
820
820
821 def _counter_pprint(obj, p, cycle):
821 def _counter_pprint(obj, p, cycle):
822 name = 'Counter'
822 name = 'Counter'
823 with p.group(len(name) + 1, name + '(', ')'):
823 with p.group(len(name) + 1, name + '(', ')'):
824 if cycle:
824 if cycle:
825 p.text('...')
825 p.text('...')
826 elif len(obj):
826 elif len(obj):
827 p.pretty(dict(obj))
827 p.pretty(dict(obj))
828
828
829 for_type_by_name('collections', 'defaultdict', _defaultdict_pprint)
829 for_type_by_name('collections', 'defaultdict', _defaultdict_pprint)
830 for_type_by_name('collections', 'OrderedDict', _ordereddict_pprint)
830 for_type_by_name('collections', 'OrderedDict', _ordereddict_pprint)
831 for_type_by_name('collections', 'deque', _deque_pprint)
831 for_type_by_name('collections', 'deque', _deque_pprint)
832 for_type_by_name('collections', 'Counter', _counter_pprint)
832 for_type_by_name('collections', 'Counter', _counter_pprint)
833
833
834 if __name__ == '__main__':
834 if __name__ == '__main__':
835 from random import randrange
835 from random import randrange
836 class Foo(object):
836 class Foo(object):
837 def __init__(self):
837 def __init__(self):
838 self.foo = 1
838 self.foo = 1
839 self.bar = re.compile(r'\s+')
839 self.bar = re.compile(r'\s+')
840 self.blub = dict.fromkeys(range(30), randrange(1, 40))
840 self.blub = dict.fromkeys(range(30), randrange(1, 40))
841 self.hehe = 23424.234234
841 self.hehe = 23424.234234
842 self.list = ["blub", "blah", self]
842 self.list = ["blub", "blah", self]
843
843
844 def get_foo(self):
844 def get_foo(self):
845 print("foo")
845 print("foo")
846
846
847 pprint(Foo(), verbose=True)
847 pprint(Foo(), verbose=True)
General Comments 0
You need to be logged in to leave comments. Login now