1 """Redo the builtin repr() (representation) but with limits on most sizes."""
2
3 __all__ = ["Repr", "repr", "recursive_repr"]
4
5 import builtins
6 from itertools import islice
7 from _thread import get_ident
8
9 def recursive_repr(fillvalue='...'):
10 'Decorator to make a repr function return fillvalue for a recursive call'
11
12 def decorating_function(user_function):
13 repr_running = set()
14
15 def wrapper(self):
16 key = id(self), get_ident()
17 if key in repr_running:
18 return fillvalue
19 repr_running.add(key)
20 try:
21 result = user_function(self)
22 finally:
23 repr_running.discard(key)
24 return result
25
26 # Can't use functools.wraps() here because of bootstrap issues
27 wrapper.__module__ = getattr(user_function, '__module__')
28 wrapper.__doc__ = getattr(user_function, '__doc__')
29 wrapper.__name__ = getattr(user_function, '__name__')
30 wrapper.__qualname__ = getattr(user_function, '__qualname__')
31 wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
32 return wrapper
33
34 return decorating_function
35
36 class ESC[4;38;5;81mRepr:
37
38 def __init__(
39 self, *, maxlevel=6, maxtuple=6, maxlist=6, maxarray=5, maxdict=4,
40 maxset=6, maxfrozenset=6, maxdeque=6, maxstring=30, maxlong=40,
41 maxother=30, fillvalue='...', indent=None,
42 ):
43 self.maxlevel = maxlevel
44 self.maxtuple = maxtuple
45 self.maxlist = maxlist
46 self.maxarray = maxarray
47 self.maxdict = maxdict
48 self.maxset = maxset
49 self.maxfrozenset = maxfrozenset
50 self.maxdeque = maxdeque
51 self.maxstring = maxstring
52 self.maxlong = maxlong
53 self.maxother = maxother
54 self.fillvalue = fillvalue
55 self.indent = indent
56
57 def repr(self, x):
58 return self.repr1(x, self.maxlevel)
59
60 def repr1(self, x, level):
61 typename = type(x).__name__
62 if ' ' in typename:
63 parts = typename.split()
64 typename = '_'.join(parts)
65 if hasattr(self, 'repr_' + typename):
66 return getattr(self, 'repr_' + typename)(x, level)
67 else:
68 return self.repr_instance(x, level)
69
70 def _join(self, pieces, level):
71 if self.indent is None:
72 return ', '.join(pieces)
73 if not pieces:
74 return ''
75 indent = self.indent
76 if isinstance(indent, int):
77 if indent < 0:
78 raise ValueError(
79 f'Repr.indent cannot be negative int (was {indent!r})'
80 )
81 indent *= ' '
82 try:
83 sep = ',\n' + (self.maxlevel - level + 1) * indent
84 except TypeError as error:
85 raise TypeError(
86 f'Repr.indent must be a str, int or None, not {type(indent)}'
87 ) from error
88 return sep.join(('', *pieces, ''))[1:-len(indent) or None]
89
90 def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
91 n = len(x)
92 if level <= 0 and n:
93 s = self.fillvalue
94 else:
95 newlevel = level - 1
96 repr1 = self.repr1
97 pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)]
98 if n > maxiter:
99 pieces.append(self.fillvalue)
100 s = self._join(pieces, level)
101 if n == 1 and trail and self.indent is None:
102 right = trail + right
103 return '%s%s%s' % (left, s, right)
104
105 def repr_tuple(self, x, level):
106 return self._repr_iterable(x, level, '(', ')', self.maxtuple, ',')
107
108 def repr_list(self, x, level):
109 return self._repr_iterable(x, level, '[', ']', self.maxlist)
110
111 def repr_array(self, x, level):
112 if not x:
113 return "array('%s')" % x.typecode
114 header = "array('%s', [" % x.typecode
115 return self._repr_iterable(x, level, header, '])', self.maxarray)
116
117 def repr_set(self, x, level):
118 if not x:
119 return 'set()'
120 x = _possibly_sorted(x)
121 return self._repr_iterable(x, level, '{', '}', self.maxset)
122
123 def repr_frozenset(self, x, level):
124 if not x:
125 return 'frozenset()'
126 x = _possibly_sorted(x)
127 return self._repr_iterable(x, level, 'frozenset({', '})',
128 self.maxfrozenset)
129
130 def repr_deque(self, x, level):
131 return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque)
132
133 def repr_dict(self, x, level):
134 n = len(x)
135 if n == 0:
136 return '{}'
137 if level <= 0:
138 return '{' + self.fillvalue + '}'
139 newlevel = level - 1
140 repr1 = self.repr1
141 pieces = []
142 for key in islice(_possibly_sorted(x), self.maxdict):
143 keyrepr = repr1(key, newlevel)
144 valrepr = repr1(x[key], newlevel)
145 pieces.append('%s: %s' % (keyrepr, valrepr))
146 if n > self.maxdict:
147 pieces.append(self.fillvalue)
148 s = self._join(pieces, level)
149 return '{%s}' % (s,)
150
151 def repr_str(self, x, level):
152 s = builtins.repr(x[:self.maxstring])
153 if len(s) > self.maxstring:
154 i = max(0, (self.maxstring-3)//2)
155 j = max(0, self.maxstring-3-i)
156 s = builtins.repr(x[:i] + x[len(x)-j:])
157 s = s[:i] + self.fillvalue + s[len(s)-j:]
158 return s
159
160 def repr_int(self, x, level):
161 s = builtins.repr(x) # XXX Hope this isn't too slow...
162 if len(s) > self.maxlong:
163 i = max(0, (self.maxlong-3)//2)
164 j = max(0, self.maxlong-3-i)
165 s = s[:i] + self.fillvalue + s[len(s)-j:]
166 return s
167
168 def repr_instance(self, x, level):
169 try:
170 s = builtins.repr(x)
171 # Bugs in x.__repr__() can cause arbitrary
172 # exceptions -- then make up something
173 except Exception:
174 return '<%s instance at %#x>' % (x.__class__.__name__, id(x))
175 if len(s) > self.maxother:
176 i = max(0, (self.maxother-3)//2)
177 j = max(0, self.maxother-3-i)
178 s = s[:i] + self.fillvalue + s[len(s)-j:]
179 return s
180
181
182 def _possibly_sorted(x):
183 # Since not all sequences of items can be sorted and comparison
184 # functions may raise arbitrary exceptions, return an unsorted
185 # sequence in that case.
186 try:
187 return sorted(x)
188 except Exception:
189 return list(x)
190
191 aRepr = Repr()
192 repr = aRepr.repr