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