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