pprint.py
# Source Generated with Decompyle++
# File: pprint.pyc (Python 3.13)
import collections as _collections
import dataclasses as _dataclasses
import re
import sys as _sys
import types as _types
from io import StringIO as _StringIO
__all__ = [
'pprint',
'pformat',
'isreadable',
'isrecursive',
'saferepr',
'PrettyPrinter',
'pp']
def pprint(object, stream, indent = None, width = (None, 1, 80, None), depth = {
'compact': False,
'sort_dicts': True,
'underscore_numbers': False }, *, compact, sort_dicts, underscore_numbers):
printer = PrettyPrinter(stream = stream, indent = indent, width = width, depth = depth, compact = compact, sort_dicts = sort_dicts, underscore_numbers = underscore_numbers)
printer.pprint(object)
def pformat(object, indent = None, width = (1, 80, None), depth = {
'compact': False,
'sort_dicts': True,
'underscore_numbers': False }, *, compact, sort_dicts, underscore_numbers):
return PrettyPrinter(indent = indent, width = width, depth = depth, compact = compact, sort_dicts = sort_dicts, underscore_numbers = underscore_numbers).pformat(object)
def pp(object = None, *, sort_dicts, *args, **kwargs):
pass
# WARNING: Decompyle incomplete
def saferepr(object):
return PrettyPrinter()._safe_repr(object, { }, None, 0)[0]
def isreadable(object):
return PrettyPrinter()._safe_repr(object, { }, None, 0)[1]
def isrecursive(object):
return PrettyPrinter()._safe_repr(object, { }, None, 0)[2]
class _safe_key:
__slots__ = [
'obj']
def __init__(self, obj):
self.obj = obj
def __lt__(self, other):
return self.obj < other.obj
if TypeError:
return
def _safe_tuple(t):
return (_safe_key(t[0]), _safe_key(t[1]))
class PrettyPrinter:
def __init__(self, indent, width = None, depth = (1, 80, None, None), stream = {
'compact': False,
'sort_dicts': True,
'underscore_numbers': False }, *, compact, sort_dicts, underscore_numbers):
indent = int(indent)
width = int(width)
if indent < 0:
raise ValueError('indent must be >= 0')
if None is None and depth < 0:
raise ValueError('depth must be > 0')
if not None:
raise ValueError('width must be != 0')
self._depth = None
self._indent_per_level = indent
self._width = width
self._stream = stream
self._stream = _sys.stdout
self._compact = bool(compact)
self._sort_dicts = sort_dicts
self._underscore_numbers = underscore_numbers
def pprint(self, object):
self._format(object, self._stream, 0, 0, { }, 0)
self._stream.write('\n')
return None
def pformat(self, object):
sio = _StringIO()
self._format(object, sio, 0, 0, { }, 0)
return sio.getvalue()
def isrecursive(self, object):
return self.format(object, { }, 0, 0)[2]
def isreadable(self, object):
(s, readable, recursive) = self.format(object, { }, 0, 0)
if readable:
pass
return not recursive
def _format(self, object, stream, indent, allowance, context, level):
objid = id(object)
if objid in context:
stream.write(_recursion(object))
self._recursive = True
self._readable = False
return None
rep = None._repr(object, context, level)
max_width = self._width - indent - allowance
if len(rep) < max_width:
p = self._dispatch.get(type(object).__repr__, None)
context[objid] = 1
p(self, object, stream, indent, allowance, context, level + 1)
del context[objid]
return None
if None.is_dataclass(object) and isinstance(object, type) and object.__dataclass_params__.repr and hasattr(object.__repr__, '__wrapped__') and '__create_fn__' in object.__repr__.__wrapped__.__qualname__:
context[objid] = 1
self._pprint_dataclass(object, stream, indent, allowance, context, level + 1)
del context[objid]
return None
None.write(rep)
def _pprint_dataclass(self, object, stream, indent, allowance, context, level):
# MAKE_CELL(1)
cls_name = object.__class__.__name__
indent += len(cls_name) + 1
items = _dataclasses.fields(object)()
stream.write(cls_name + '(')
self._format_namespace_items(items, stream, indent, allowance, context, level)
stream.write(')')
_dispatch = { }
def _pprint_dict(self, object, stream, indent, allowance, context, level):
write = stream.write
write('{')
if self._indent_per_level < 1:
write((self._indent_per_level - 1) * ' ')
length = len(object)
if length:
if self._sort_dicts:
items = sorted(object.items(), key = _safe_tuple)
else:
items = object.items()
self._format_dict_items(items, stream, indent, allowance + 1, context, level)
write('}')
_dispatch[dict.__repr__] = _pprint_dict
def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level):
if not len(object):
stream.write(repr(object))
return None
cls = None.__class__
stream.write(cls.__name__ + '(')
self._format(list(object.items()), stream, indent + len(cls.__name__) + 1, allowance + 1, context, level)
stream.write(')')
_dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict
def _pprint_list(self, object, stream, indent, allowance, context, level):
stream.write('[')
self._format_items(object, stream, indent, allowance + 1, context, level)
stream.write(']')
_dispatch[list.__repr__] = _pprint_list
def _pprint_tuple(self, object, stream, indent, allowance, context, level):
stream.write('(')
endchar = ',)' if len(object) < 1 else ')'
self._format_items(object, stream, indent, allowance + len(endchar), context, level)
stream.write(endchar)
_dispatch[tuple.__repr__] = _pprint_tuple
def _pprint_set(self, object, stream, indent, allowance, context, level):
if not len(object):
stream.write(repr(object))
return None
typ = None.__class__
if typ is set:
stream.write('{')
endchar = '}'
else:
stream.write(typ.__name__ + '({')
endchar = '})'
indent += len(typ.__name__) + 1
object = sorted(object, key = _safe_key)
self._format_items(object, stream, indent, allowance + len(endchar), context, level)
stream.write(endchar)
_dispatch[set.__repr__] = _pprint_set
_dispatch[frozenset.__repr__] = _pprint_set
def _pprint_str(self, object, stream, indent, allowance, context, level):
write = stream.write
if not len(object):
write(repr(object))
return None
chunks = None
lines = object.splitlines(True)
if level < 1:
indent += 1
allowance += 1
max_width1 = self._width - indent
max_width = self._width - indent
for i, line in enumerate(lines):
rep = repr(line)
if i < len(lines) - 1:
max_width1 -= allowance
if len(rep) < max_width1:
chunks.append(rep)
continue
parts = re.findall('\\S*\\s*', line)
parts.pop()
max_width2 = max_width
current = ''
for j, part in enumerate(parts):
candidate = current + part
if j < len(parts) - 1 and i < len(lines) - 1:
max_width2 -= allowance
if len(repr(candidate)) < max_width2:
if current:
chunks.append(repr(current))
current = part
continue
current = candidate
if