Lib/repr.py

   1 """Redo the builtin repr() (representation) but with limits on most sizes."""
   2
   3 __all__ = ["Repr","repr"]
   4
   5 import __builtin__
   6 from itertools import islice
   7
   8 class Repr:
   9
  10     def __init__(self):
  11         self.maxlevel = 6
  12         self.maxtuple = 6
  13         self.maxlist = 6
  14         self.maxarray = 5
  15         self.maxdict = 4
  16         self.maxset = 6
  17         self.maxfrozenset = 6
  18         self.maxdeque = 6
  19         self.maxstring = 30
  20         self.maxlong = 40
  21         self.maxother = 20
  22
  23     def repr(self, x):
  24         return self.repr1(x, self.maxlevel)
  25
  26     def repr1(self, x, level):
  27         typename = type(x).__name__
  28         if ' ' in typename:
  29             parts = typename.split()
  30             typename = '_'.join(parts)
  31         if hasattr(self, 'repr_' + typename):
  32             return getattr(self, 'repr_' + typename)(x, level)
  33         else:
  34             s = __builtin__.repr(x)
  35             if len(s) > self.maxother:
  36                 i = max(0, (self.maxother-3)//2)
  37                 j = max(0, self.maxother-3-i)
  38                 s = s[:i] + '...' + s[len(s)-j:]
  39             return s
  40
  41     def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
  42         n = len(x)
  43         if level <= 0 and n:
  44             s = '...'
  45         else:
  46             newlevel = level - 1
  47             repr1 = self.repr1
  48             pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)]
  49             if n > maxiter:  pieces.append('...')
  50             s = ', '.join(pieces)
  51             if n == 1 and trail:  right = trail + right
  52         return '%s%s%s' % (left, s, right)
  53
  54     def repr_tuple(self, x, level):
  55         return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',')
  56
  57     def repr_list(self, x, level):
  58         return self._repr_iterable(x, level, '[', ']', self.maxlist)
  59
  60     def repr_array(self, x, level):
  61         header = "array('%s', [" % x.typecode
  62         return self._repr_iterable(x, level, header, '])', self.maxarray)
  63
  64     def repr_set(self, x, level):
  65         x = _possibly_sorted(x)
  66         return self._repr_iterable(x, level, 'set([', '])', self.maxset)
  67
  68     def repr_frozenset(self, x, level):
  69         x = _possibly_sorted(x)
  70         return self._repr_iterable(x, level, 'frozenset([', '])',
  71                                    self.maxfrozenset)
  72
  73     def repr_deque(self, x, level):
  74         return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque)
  75
  76     def repr_dict(self, x, level):
  77         n = len(x)
  78         if n == 0: return '{}'
  79         if level <= 0: return '{...}'
  80         newlevel = level - 1
  81         repr1 = self.repr1
  82         pieces = []
  83         for key in islice(_possibly_sorted(x), self.maxdict):
  84             keyrepr = repr1(key, newlevel)
  85             valrepr = repr1(x[key], newlevel)
  86             pieces.append('%s: %s' % (keyrepr, valrepr))
  87         if n > self.maxdict: pieces.append('...')
  88         s = ', '.join(pieces)
  89         return '{%s}' % (s,)
  90
  91     def repr_str(self, x, level):
  92         s = __builtin__.repr(x[:self.maxstring])
  93         if len(s) > self.maxstring:
  94             i = max(0, (self.maxstring-3)//2)
  95             j = max(0, self.maxstring-3-i)
  96             s = __builtin__.repr(x[:i] + x[len(x)-j:])
  97             s = s[:i] + '...' + s[len(s)-j:]
  98         return s
  99
 100     def repr_long(self, x, level):
 101         s = __builtin__.repr(x) # XXX Hope this isn't too slow...
 102         if len(s) > self.maxlong:
 103             i = max(0, (self.maxlong-3)//2)
 104             j = max(0, self.maxlong-3-i)
 105             s = s[:i] + '...' + s[len(s)-j:]
 106         return s
 107
 108     def repr_instance(self, x, level):
 109         try:
 110             s = __builtin__.repr(x)
 111             # Bugs in x.__repr__() can cause arbitrary
 112             # exceptions -- then make up something
 113         except Exception:
 114             return '<%s instance at %x>' % (x.__class__.__name__, id(x))
 115         if len(s) > self.maxstring:
 116             i = max(0, (self.maxstring-3)//2)
 117             j = max(0, self.maxstring-3-i)
 118             s = s[:i] + '...' + s[len(s)-j:]
 119         return s
 120
 121
 122 def _possibly_sorted(x):
 123     # Since not all sequences of items can be sorted and comparison
 124     # functions may raise arbitrary exceptions, return an unsorted
 125     # sequence in that case.
 126     try:
 127         return sorted(x)
 128     except Exception:
 129         return list(x)
 130
 131 aRepr = Repr()
 132 repr = aRepr.repr