← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Lib/reprlib.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

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