def _format(self, object, stream, indent, allowance, context, level):
objid = id(object)
if objid in context:
stream.write(pprint._recursion(object))
self._recursive = True
self._readable = False
return
if hasattr(object, '__properties'):
# we use our str representation as a safe repr
rep = str(object)
if hasattr(object, 'isLiteralClass'):
if len(rep) >= self._maxStrLen:
rep = rep[:self._maxStrLen] + '+%i...' % (len(rep) -
self._maxStrLen)
elif is_collection(object):
max_coll_len = self._maxCollLen
if self._depth is not None:
max_coll_len = (1 + self._depth - level) * self._maxCollLen
if is_mapping(object):
rep = self._repr(
{k: v
for k, v in islice(object.items(), 0, self._maxEl)},
context, level)
if len(object) >= self._maxEl:
rep = rreplace(rep, '}',
'+%i...}' % (len(object) - self._maxEl))
if len(rep) >= max_coll_len:
rep = rep[:max_coll_len] + '...}'
else:
rep = self._repr([v for v in object[0:self._maxEl]], context,
level)
if len(object) >= self._maxEl:
rep = rreplace(rep, ']',
'+%i...]' % (len(object) - self._maxEl))
if len(rep) >= max_coll_len:
rep = rep[:max_coll_len] + '...]'
elif is_string(object) and len(object) >= self._maxStrLen:
object = object[:self.
_maxStrLen] + f'+{len(object) - self._maxStrLen}...'
rep = self._repr(object, context, level)
else:
rep = self._repr(object, context, level)
max_width = self._width - indent - allowance
if len(rep) > max_width:
p = self._dispatch.get(type(object).__repr__, None)
if p is not None:
context[objid] = 1
p(self, object, stream, indent, allowance, context, level + 1)
del context[objid]
return
elif isinstance(object, dict):
context[objid] = 1
self._pprint_dict(object, stream, indent, allowance, context,
level + 1)
del context[objid]
return
stream.write(rep)
def _format(self, object, stream, indent, allowance, context, level):
if level == 0:
self.visited.clear()
objid = id(object)
if objid in context:
stream.write(_recursion(object))
self._recursive = True
self._readable = False
return
rep = self._repr(object, context, level)
max_width = self._width - indent - allowance
if isinstance(object, (PynamoModel, MapAttribute)) and type(object) not in (
self.force_use_repr_types or []
):
# Don't use default repr
rep = (
f"{object.__class__.__qualname__}("
+ ", ".join(
f"{k}={self._repr(getattr(object, k), context, level + 1)}" for k in object._attributes.keys()
)
+ ")"
)
if not self.force_use_repr(object) and (not self.allow_use_repr(object) or len(rep) > max_width):
p = self._dispatch.get(type(object).__repr__, None)
# Modification: use custom _pprint_dict before using from _dispatch
# Modification: add _pprint_dataclass
if isinstance(object, list):
context[objid] = 1
self._pprint_list(object, stream, indent, allowance, context, level + 1)
del context[objid]
return
if isinstance(object, dict):
context[objid] = 1
self._pprint_dict(object, stream, indent, allowance, context, level + 1)
del context[objid]
return
elif is_dataclass(object):
context[objid] = 1
self._pprint_dataclass(object, stream, indent, allowance, context, level + 1)
del context[objid]
return
elif isinstance(object, (PynamoModel, MapAttribute)):
context[objid] = 1
self._pprint_pynamo_model(object, stream, indent, allowance, context, level + 1)
del context[objid]
return
elif p is not None:
context[objid] = 1
p(self, object, stream, indent, allowance, context, level + 1)
del context[objid]
return
stream.write(rep)
def _format(self, query, stream, indent, allowance, context, level):
level = level + 1
objid = id(query)
if objid in context:
stream.write(_recursion(query))
self._recursive = True
self._readable = False
return
rep = self._repr(query, context, level - 1)
typ = type(query)
sepLines = len(rep) > (self._width - 1 - indent - allowance)
write = stream.write
if self._depth and level > self._depth:
write(rep)
return
if issubclass(typ, (_AndQuery, _OrQuery, NotQuery)):
write('<%s.%s(' % (
query.__module__,
query.__class__.__name__))
if self._indent_per_level > 1:
write((self._indent_per_level - 1) * ' ')
if issubclass(typ, NotQuery):
atoms = [query.query]
else:
atoms = query.atoms
if atoms:
context[objid] = 1
indent = indent + self._indent_per_level
for atom in atoms:
if sepLines:
write('\n%s' % (' ' * indent))
self._format(atom, stream, indent + 2,
allowance + 1, context, level)
indent = indent - self._indent_per_level
del context[objid]
write('>')
return
write(rep)
def reprstream(stack, seen=None, maxlevels=3, level=0, isinstance=isinstance):
"""Streaming repr, yielding tokens."""
# type: (deque, Set, int, int, Callable) -> Iterator[Any]
seen = seen or set()
append = stack.append
popleft = stack.popleft
is_in_seen = seen.__contains__
discard_from_seen = seen.discard
add_to_seen = seen.add
while stack:
lit_start = lit_end = None
it = popleft()
for val in it:
orig = val
if isinstance(val, _dirty):
discard_from_seen(val.objid)
continue
elif isinstance(val, _literal):
level += val.direction
yield val, it
elif isinstance(val, _key):
yield val, it
elif isinstance(val, Decimal):
yield _repr(val), it
elif isinstance(val, safe_t):
yield text_t(val), it
elif isinstance(val, chars_t):
yield _quoted(val), it
elif isinstance(val, range_t): # pragma: no cover
yield _repr(val), it
else:
if isinstance(val, set_t):
if not val:
yield _repr_empty_set(val), it
continue
lit_start, lit_end, val = _reprseq(
val,
LIT_SET_START,
LIT_SET_END,
set,
_chainlist,
)
elif isinstance(val, tuple):
lit_start, lit_end, val = (LIT_TUPLE_START,
LIT_TUPLE_END_SV if len(val)
== 1 else LIT_TUPLE_END,
_chainlist(val))
elif isinstance(val, dict):
lit_start, lit_end, val = (LIT_DICT_START, LIT_DICT_END,
_chaindict(val))
elif isinstance(val, list):
lit_start, lit_end, val = (LIT_LIST_START, LIT_LIST_END,
_chainlist(val))
else:
# other type of object
yield _repr(val), it
continue
if maxlevels and level >= maxlevels:
yield '%s...%s' % (lit_start.value, lit_end.value), it
continue
objid = id(orig)
if is_in_seen(objid):
yield _recursion(orig), it
continue
add_to_seen(objid)
# Recurse into the new list/tuple/dict/etc by tacking
# the rest of our iterable onto the new it: this way
# it works similar to a linked list.
append(chain([lit_start], val, [_dirty(objid), lit_end], it))
break
def reprstream(stack, seen=None, maxlevels=3, level=0, isinstance=isinstance):
"""Streaming repr, yielding tokens."""
seen = seen or set()
append = stack.append
popleft = stack.popleft
is_in_seen = seen.__contains__
discard_from_seen = seen.discard
add_to_seen = seen.add
while stack:
lit_start = lit_end = None
it = popleft()
for val in it:
orig = val
if isinstance(val, _dirty):
discard_from_seen(val.objid)
continue
elif isinstance(val, _literal):
level += val.direction
yield val, it
elif isinstance(val, _key):
yield val, it
elif isinstance(val, Decimal):
yield repr(val), it
elif isinstance(val, safe_t):
yield text_t(val), it
elif isinstance(val, chars_t):
yield _quoted(val), it
elif isinstance(val, range_t): # pragma: no cover
yield repr(val), it
else:
if isinstance(val, set_t):
if not val:
yield _repr_empty_set(val), it
continue
lit_start, lit_end, val = _reprseq(val, LIT_SET_START, LIT_SET_END, set, _chainlist)
elif isinstance(val, tuple):
lit_start, lit_end, val = (
LIT_TUPLE_START,
LIT_TUPLE_END_SV if len(val) == 1 else LIT_TUPLE_END,
_chainlist(val),
)
elif isinstance(val, Mapping):
lit_start, lit_end, val = (LIT_DICT_START, LIT_DICT_END, _chaindict(val))
elif isinstance(val, Iterable):
lit_start, lit_end, val = (LIT_LIST_START, LIT_LIST_END, _chainlist(val))
else:
# other type of object
yield repr(val), it
continue
if maxlevels and level >= maxlevels:
yield "%s...%s" % (lit_start.value, lit_end.value), it
continue
objid = id(orig)
if is_in_seen(objid):
yield _recursion(orig), it
continue
add_to_seen(objid)
# Recurse into the new list/tuple/dict/etc by tacking
# the rest of our iterable onto the new it: this way
# it works similar to a linked list.
append(chain([lit_start], val, [_dirty(objid), lit_end], it))
break
def _safe_repr(object, context, maxlevels, level, changed_only=False):
"""Same as the builtin _safe_repr, with added support for Estimator
objects."""
typ = type(object)
if typ in pprint._builtin_scalars:
return repr(object), True, False
r = getattr(typ, "__repr__", None)
if issubclass(typ, dict) and r is dict.__repr__:
if not object:
return "{}", True, False
objid = id(object)
if maxlevels and level >= maxlevels:
return "{...}", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
saferepr = _safe_repr
items = sorted(object.items(), key=pprint._safe_tuple)
for k, v in items:
krepr, kreadable, krecur = saferepr(k,
context,
maxlevels,
level,
changed_only=changed_only)
vrepr, vreadable, vrecur = saferepr(v,
context,
maxlevels,
level,
changed_only=changed_only)
append("%s: %s" % (krepr, vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
recursive = True
del context[objid]
return "{%s}" % ", ".join(components), readable, recursive
if (issubclass(typ, list) and r is list.__repr__) or \
(issubclass(typ, tuple) and r is tuple.__repr__):
if issubclass(typ, list):
if not object:
return "[]", True, False
format = "[%s]"
elif len(object) == 1:
format = "(%s,)"
else:
if not object:
return "()", True, False
format = "(%s)"
objid = id(object)
if maxlevels and level >= maxlevels:
return format % "...", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
for o in object:
orepr, oreadable, orecur = _safe_repr(o,
context,
maxlevels,
level,
changed_only=changed_only)
append(orepr)
if not oreadable:
readable = False
if orecur:
recursive = True
del context[objid]
return format % ", ".join(components), readable, recursive
if issubclass(typ, BaseEstimator):
objid = id(object)
if maxlevels and level >= maxlevels:
return "{...}", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
if changed_only:
params = _changed_params(object)
else:
params = object.get_params(deep=False)
components = []
append = components.append
level += 1
saferepr = _safe_repr
items = sorted(params.items(), key=pprint._safe_tuple)
for k, v in items:
krepr, kreadable, krecur = saferepr(k,
context,
maxlevels,
level,
changed_only=changed_only)
vrepr, vreadable, vrecur = saferepr(v,
context,
maxlevels,
level,
changed_only=changed_only)
append("%s=%s" % (krepr.strip("'"), vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
recursive = True
del context[objid]
return ("%s(%s)" % (typ.__name__, ", ".join(components)), readable,
recursive)
rep = repr(object)
return rep, (rep and not rep.startswith('<')), False
def _safe_repr(object, context, maxlevels, level, changed_only=False):
"""Same as the builtin _safe_repr, with added support for Estimator
objects."""
typ = type(object)
if typ in pprint._builtin_scalars:
return repr(object), True, False
r = getattr(typ, "__repr__", None)
if issubclass(typ, dict) and r is dict.__repr__:
if not object:
return "{}", True, False
objid = id(object)
if maxlevels and level >= maxlevels:
return "{...}", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
saferepr = _safe_repr
items = sorted(object.items(), key=pprint._safe_tuple)
for k, v in items:
krepr, kreadable, krecur = saferepr(
k, context, maxlevels, level, changed_only=changed_only)
vrepr, vreadable, vrecur = saferepr(
v, context, maxlevels, level, changed_only=changed_only)
append("%s: %s" % (krepr, vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
recursive = True
del context[objid]
return "{%s}" % ", ".join(components), readable, recursive
if (issubclass(typ, list) and r is list.__repr__) or \
(issubclass(typ, tuple) and r is tuple.__repr__):
if issubclass(typ, list):
if not object:
return "[]", True, False
format = "[%s]"
elif len(object) == 1:
format = "(%s,)"
else:
if not object:
return "()", True, False
format = "(%s)"
objid = id(object)
if maxlevels and level >= maxlevels:
return format % "...", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
for o in object:
orepr, oreadable, orecur = _safe_repr(
o, context, maxlevels, level, changed_only=changed_only)
append(orepr)
if not oreadable:
readable = False
if orecur:
recursive = True
del context[objid]
return format % ", ".join(components), readable, recursive
if issubclass(typ, BaseEstimator):
objid = id(object)
if maxlevels and level >= maxlevels:
return "{...}", False, objid in context
if objid in context:
return pprint._recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
if changed_only:
params = _changed_params(object)
else:
params = object.get_params(deep=False)
components = []
append = components.append
level += 1
saferepr = _safe_repr
items = sorted(params.items(), key=pprint._safe_tuple)
for k, v in items:
krepr, kreadable, krecur = saferepr(
k, context, maxlevels, level, changed_only=changed_only)
vrepr, vreadable, vrecur = saferepr(
v, context, maxlevels, level, changed_only=changed_only)
append("%s=%s" % (krepr.strip("'"), vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
recursive = True
del context[objid]
return ("%s(%s)" % (typ.__name__, ", ".join(components)), readable,
recursive)
rep = repr(object)
return rep, (rep and not rep.startswith('<')), False
def update_event(self, inp=-1):
self.set_output_val(0, pprint._recursion(self.input(0)))
def _format(self, object, stream, indent, allowance, context, level):
if not allowance:
allowance = 0
level = level + 1
objid = id(object)
if objid in context:
stream.write(self._colours['value'])
stream.write(orig_pprint._recursion(object))
self._recursive = True
self._readable = False
return
rep = self._repr(object, context, level - 1)
typ = type(object)
write = stream.write
r = getattr(typ, '__repr__', None)
if issubclass(typ, dict) and r is dict.__repr__:
write('{')
length = len(object)
if length:
write('\n')
write((indent * level) * ' ')
context[objid] = 1
items = sorted(object.items())
key, ent = items[0]
rep = self._repr(key, context, level)
write(self._colours['key'])
write(rep)
write(self._colours['syntax'])
write(': ')
self._format(ent, stream, indent, allowance + 1, context, \
level)
for key, ent in items[1:]:
rep = self._repr(key, context, level)
write(self._colours['syntax'])
write(',')
write('\n')
write(' ' * (indent * level))
write(self._colours['key'])
write(rep)
write(self._colours['syntax'])
write(': ')
self._format(ent, stream, indent, allowance + 1, \
context, level)
del context[objid]
write(self._colours['syntax'])
write(',')
write('\n')
write(' ' * (indent * (level - 1)))
write(self._colours['syntax'])
write('}')
return
if (issubclass(typ, list) and r is list.__repr__) or \
(issubclass(typ, tuple) and r is tuple.__repr__):
write(self._colours['syntax'])
if issubclass(typ, list):
write('[')
endchar = self._colours['syntax'] + ']'
else:
write('(')
endchar = self._colours['syntax'] + ')'
length = len(object)
if length:
write('\n')
write(' ' * (indent * level))
context[objid] = 1
self._format(object[0], stream, indent, allowance + 1, \
context, level)
for ent in object[1:]:
write(self._colours['syntax'])
write(',')
write('\n')
write(' ' * (indent * level))
self._format(ent, stream, indent, allowance + 1, \
context, level)
del context[objid]
write(self._colours['syntax'])
write(',')
write('\n')
write(' ' * (indent * (level - 1)))
write(endchar)
return
write(self._colours['value'])
write(rep)
