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)