symbian-qemu-0.9.1-12/python-win32-2.6.1/lib/repr.py
changeset 1 2fb8b9db1c86
equal deleted inserted replaced
0:ffa851df0825 1:2fb8b9db1c86
       
     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