logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

pprint.py (24423B)

    

  1. #  Author:      Fred L. Drake, Jr.
  2. #               fdrake@acm.org
  3. #
  4. #  This is a simple little module I wrote to make life easier.  I didn't
  5. #  see anything quite like it in the library, though I may have overlooked
  6. #  something.  I wrote this when I was trying to read some heavily nested
  7. #  tuples with fairly non-descriptive content.  This is modeled very much
  8. #  after Lisp/Scheme - style pretty-printing of lists.  If you find it
  9. #  useful, thank small children who sleep at night.
  11. """Support to pretty-print lists, tuples, & dictionaries recursively.
  13. Very simple, but useful, especially in debugging data structures.
  15. Classes
  16. -------
  18. PrettyPrinter()
  19.     Handle pretty-printing operations onto a stream using a configured
  20.     set of formatting parameters.
  22. Functions
  23. ---------
  25. pformat()
  26.     Format a Python object into a pretty-printed representation.
  28. pprint()
  29.     Pretty-print a Python object to a stream [default is sys.stdout].
  31. saferepr()
  32.     Generate a 'standard' repr()-like value, but protect against recursive
  33.     data structures.
  35. """
  37. import collections as _collections
  38. import dataclasses as _dataclasses
  39. import re
  40. import sys as _sys
  41. import types as _types
  42. from io import StringIO as _StringIO
  44. __all__ = ["pprint","pformat","isreadable","isrecursive","saferepr",
  45.            "PrettyPrinter", "pp"]
  48. def pprint(object, stream=None, indent=1, width=80, depth=None, *,
  49.            compact=False, sort_dicts=True, underscore_numbers=False):
  50.     """Pretty-print a Python object to a stream [default is sys.stdout]."""
  51.     printer = PrettyPrinter(
  52.         stream=stream, indent=indent, width=width, depth=depth,
  53.         compact=compact, sort_dicts=sort_dicts, underscore_numbers=False)
  54.     printer.pprint(object)
  56. def pformat(object, indent=1, width=80, depth=None, *,
  57.             compact=False, sort_dicts=True, underscore_numbers=False):
  58.     """Format a Python object into a pretty-printed representation."""
  59.     return PrettyPrinter(indent=indent, width=width, depth=depth,
  60.                          compact=compact, sort_dicts=sort_dicts,
  61.                          underscore_numbers=underscore_numbers).pformat(object)
  63. def pp(object, *args, sort_dicts=False, **kwargs):
  64.     """Pretty-print a Python object"""
  65.     pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
  67. def saferepr(object):
  68.     """Version of repr() which can handle recursive data structures."""
  69.     return PrettyPrinter()._safe_repr(object, {}, None, 0)[0]
  71. def isreadable(object):
  72.     """Determine if saferepr(object) is readable by eval()."""
  73.     return PrettyPrinter()._safe_repr(object, {}, None, 0)[1]
  75. def isrecursive(object):
  76.     """Determine if object requires a recursive representation."""
  77.     return PrettyPrinter()._safe_repr(object, {}, None, 0)[2]
  79. class _safe_key:
  80.     """Helper function for key functions when sorting unorderable objects.
  82.     The wrapped-object will fallback to a Py2.x style comparison for
  83.     unorderable types (sorting first comparing the type name and then by
  84.     the obj ids).  Does not work recursively, so dict.items() must have
  85.     _safe_key applied to both the key and the value.
  87.     """
  89.     __slots__ = ['obj']
  91.     def __init__(self, obj):
  92.         self.obj = obj
  94.     def __lt__(self, other):
  95.         try:
  96.             return self.obj < other.obj
  97.         except TypeError:
  98.             return ((str(type(self.obj)), id(self.obj)) < \
  99.                     (str(type(other.obj)), id(other.obj)))
  101. def _safe_tuple(t):
  102.     "Helper function for comparing 2-tuples"
  103.     return _safe_key(t[0]), _safe_key(t[1])
  105. class PrettyPrinter:
  106.     def __init__(self, indent=1, width=80, depth=None, stream=None, *,
  107.                  compact=False, sort_dicts=True, underscore_numbers=False):
  108.         """Handle pretty printing operations onto a stream using a set of
  109.         configured parameters.
  111.         indent
  112.             Number of spaces to indent for each level of nesting.
  114.         width
  115.             Attempted maximum number of columns in the output.
  117.         depth
  118.             The maximum depth to print out nested structures.
  120.         stream
  121.             The desired output stream.  If omitted (or false), the standard
  122.             output stream available at construction will be used.
  124.         compact
  125.             If true, several items will be combined in one line.
  127.         sort_dicts
  128.             If true, dict keys are sorted.
  130.         """
  131.         indent = int(indent)
  132.         width = int(width)
  133.         if indent < 0:
  134.             raise ValueError('indent must be >= 0')
  135.         if depth is not None and depth <= 0:
  136.             raise ValueError('depth must be > 0')
  137.         if not width:
  138.             raise ValueError('width must be != 0')
  139.         self._depth = depth
  140.         self._indent_per_level = indent
  141.         self._width = width
  142.         if stream is not None:
  143.             self._stream = stream
  144.         else:
  145.             self._stream = _sys.stdout
  146.         self._compact = bool(compact)
  147.         self._sort_dicts = sort_dicts
  148.         self._underscore_numbers = underscore_numbers
  150.     def pprint(self, object):
  151.         self._format(object, self._stream, 0, 0, {}, 0)
  152.         self._stream.write("\n")
  154.     def pformat(self, object):
  155.         sio = _StringIO()
  156.         self._format(object, sio, 0, 0, {}, 0)
  157.         return sio.getvalue()
  159.     def isrecursive(self, object):
  160.         return self.format(object, {}, 0, 0)[2]
  162.     def isreadable(self, object):
  163.         s, readable, recursive = self.format(object, {}, 0, 0)
  164.         return readable and not recursive
  166.     def _format(self, object, stream, indent, allowance, context, level):
  167.         objid = id(object)
  168.         if objid in context:
  169.             stream.write(_recursion(object))
  170.             self._recursive = True
  171.             self._readable = False
  172.             return
  173.         rep = self._repr(object, context, level)
  174.         max_width = self._width - indent - allowance
  175.         if len(rep) > max_width:
  176.             p = self._dispatch.get(type(object).__repr__, None)
  177.             if p is not None:
  178.                 context[objid] = 1
  179.                 p(self, object, stream, indent, allowance, context, level + 1)
  180.                 del context[objid]
  181.                 return
  182.             elif (_dataclasses.is_dataclass(object) and
  183.                   not isinstance(object, type) and
  184.                   object.__dataclass_params__.repr and
  185.                   # Check dataclass has generated repr method.
  186.                   hasattr(object.__repr__, "__wrapped__") and
  187.                   "__create_fn__" in object.__repr__.__wrapped__.__qualname__):
  188.                 context[objid] = 1
  189.                 self._pprint_dataclass(object, stream, indent, allowance, context, level + 1)
  190.                 del context[objid]
  191.                 return
  192.         stream.write(rep)
  194.     def _pprint_dataclass(self, object, stream, indent, allowance, context, level):
  195.         cls_name = object.__class__.__name__
  196.         indent += len(cls_name) + 1
  197.         items = [(f.name, getattr(object, f.name)) for f in _dataclasses.fields(object) if f.repr]
  198.         stream.write(cls_name + '(')
  199.         self._format_namespace_items(items, stream, indent, allowance, context, level)
  200.         stream.write(')')
  202.     _dispatch = {}
  204.     def _pprint_dict(self, object, stream, indent, allowance, context, level):
  205.         write = stream.write
  206.         write('{')
  207.         if self._indent_per_level > 1:
  208.             write((self._indent_per_level - 1) * ' ')
  209.         length = len(object)
  210.         if length:
  211.             if self._sort_dicts:
  212.                 items = sorted(object.items(), key=_safe_tuple)
  213.             else:
  214.                 items = object.items()
  215.             self._format_dict_items(items, stream, indent, allowance + 1,
  216.                                     context, level)
  217.         write('}')
  219.     _dispatch[dict.__repr__] = _pprint_dict
  221.     def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level):
  222.         if not len(object):
  223.             stream.write(repr(object))
  224.             return
  225.         cls = object.__class__
  226.         stream.write(cls.__name__ + '(')
  227.         self._format(list(object.items()), stream,
  228.                      indent + len(cls.__name__) + 1, allowance + 1,
  229.                      context, level)
  230.         stream.write(')')
  232.     _dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict
  234.     def _pprint_list(self, object, stream, indent, allowance, context, level):
  235.         stream.write('[')
  236.         self._format_items(object, stream, indent, allowance + 1,
  237.                            context, level)
  238.         stream.write(']')
  240.     _dispatch[list.__repr__] = _pprint_list
  242.     def _pprint_tuple(self, object, stream, indent, allowance, context, level):
  243.         stream.write('(')
  244.         endchar = ',)' if len(object) == 1 else ')'
  245.         self._format_items(object, stream, indent, allowance + len(endchar),
  246.                            context, level)
  247.         stream.write(endchar)
  249.     _dispatch[tuple.__repr__] = _pprint_tuple
  251.     def _pprint_set(self, object, stream, indent, allowance, context, level):
  252.         if not len(object):
  253.             stream.write(repr(object))
  254.             return
  255.         typ = object.__class__
  256.         if typ is set:
  257.             stream.write('{')
  258.             endchar = '}'
  259.         else:
  260.             stream.write(typ.__name__ + '({')
  261.             endchar = '})'
  262.             indent += len(typ.__name__) + 1
  263.         object = sorted(object, key=_safe_key)
  264.         self._format_items(object, stream, indent, allowance + len(endchar),
  265.                            context, level)
  266.         stream.write(endchar)
  268.     _dispatch[set.__repr__] = _pprint_set
  269.     _dispatch[frozenset.__repr__] = _pprint_set
  271.     def _pprint_str(self, object, stream, indent, allowance, context, level):
  272.         write = stream.write
  273.         if not len(object):
  274.             write(repr(object))
  275.             return
  276.         chunks = []
  277.         lines = object.splitlines(True)
  278.         if level == 1:
  279.             indent += 1
  280.             allowance += 1
  281.         max_width1 = max_width = self._width - indent
  282.         for i, line in enumerate(lines):
  283.             rep = repr(line)
  284.             if i == len(lines) - 1:
  285.                 max_width1 -= allowance
  286.             if len(rep) <= max_width1:
  287.                 chunks.append(rep)
  288.             else:
  289.                 # A list of alternating (non-space, space) strings
  290.                 parts = re.findall(r'\S*\s*', line)
  291.                 assert parts
  292.                 assert not parts[-1]
  293.                 parts.pop()  # drop empty last part
  294.                 max_width2 = max_width
  295.                 current = ''
  296.                 for j, part in enumerate(parts):
  297.                     candidate = current + part
  298.                     if j == len(parts) - 1 and i == len(lines) - 1:
  299.                         max_width2 -= allowance
  300.                     if len(repr(candidate)) > max_width2:
  301.                         if current:
  302.                             chunks.append(repr(current))
  303.                         current = part
  304.                     else:
  305.                         current = candidate
  306.                 if current:
  307.                     chunks.append(repr(current))
  308.         if len(chunks) == 1:
  309.             write(rep)
  310.             return
  311.         if level == 1:
  312.             write('(')
  313.         for i, rep in enumerate(chunks):
  314.             if i > 0:
  315.                 write('\n' + ' '*indent)
  316.             write(rep)
  317.         if level == 1:
  318.             write(')')
  320.     _dispatch[str.__repr__] = _pprint_str
  322.     def _pprint_bytes(self, object, stream, indent, allowance, context, level):
  323.         write = stream.write
  324.         if len(object) <= 4:
  325.             write(repr(object))
  326.             return
  327.         parens = level == 1
  328.         if parens:
  329.             indent += 1
  330.             allowance += 1
  331.             write('(')
  332.         delim = ''
  333.         for rep in _wrap_bytes_repr(object, self._width - indent, allowance):
  334.             write(delim)
  335.             write(rep)
  336.             if not delim:
  337.                 delim = '\n' + ' '*indent
  338.         if parens:
  339.             write(')')
  341.     _dispatch[bytes.__repr__] = _pprint_bytes
  343.     def _pprint_bytearray(self, object, stream, indent, allowance, context, level):
  344.         write = stream.write
  345.         write('bytearray(')
  346.         self._pprint_bytes(bytes(object), stream, indent + 10,
  347.                            allowance + 1, context, level + 1)
  348.         write(')')
  350.     _dispatch[bytearray.__repr__] = _pprint_bytearray
  352.     def _pprint_mappingproxy(self, object, stream, indent, allowance, context, level):
  353.         stream.write('mappingproxy(')
  354.         self._format(object.copy(), stream, indent + 13, allowance + 1,
  355.                      context, level)
  356.         stream.write(')')
  358.     _dispatch[_types.MappingProxyType.__repr__] = _pprint_mappingproxy
  360.     def _pprint_simplenamespace(self, object, stream, indent, allowance, context, level):
  361.         if type(object) is _types.SimpleNamespace:
  362.             # The SimpleNamespace repr is "namespace" instead of the class
  363.             # name, so we do the same here. For subclasses; use the class name.
  364.             cls_name = 'namespace'
  365.         else:
  366.             cls_name = object.__class__.__name__
  367.         indent += len(cls_name) + 1
  368.         items = object.__dict__.items()
  369.         stream.write(cls_name + '(')
  370.         self._format_namespace_items(items, stream, indent, allowance, context, level)
  371.         stream.write(')')
  373.     _dispatch[_types.SimpleNamespace.__repr__] = _pprint_simplenamespace
  375.     def _format_dict_items(self, items, stream, indent, allowance, context,
  376.                            level):
  377.         write = stream.write
  378.         indent += self._indent_per_level
  379.         delimnl = ',\n' + ' ' * indent
  380.         last_index = len(items) - 1
  381.         for i, (key, ent) in enumerate(items):
  382.             last = i == last_index
  383.             rep = self._repr(key, context, level)
  384.             write(rep)
  385.             write(': ')
  386.             self._format(ent, stream, indent + len(rep) + 2,
  387.                          allowance if last else 1,
  388.                          context, level)
  389.             if not last:
  390.                 write(delimnl)
  392.     def _format_namespace_items(self, items, stream, indent, allowance, context, level):
  393.         write = stream.write
  394.         delimnl = ',\n' + ' ' * indent
  395.         last_index = len(items) - 1
  396.         for i, (key, ent) in enumerate(items):
  397.             last = i == last_index
  398.             write(key)
  399.             write('=')
  400.             if id(ent) in context:
  401.                 # Special-case representation of recursion to match standard
  402.                 # recursive dataclass repr.
  403.                 write("...")
  404.             else:
  405.                 self._format(ent, stream, indent + len(key) + 1,
  406.                              allowance if last else 1,
  407.                              context, level)
  408.             if not last:
  409.                 write(delimnl)
  411.     def _format_items(self, items, stream, indent, allowance, context, level):
  412.         write = stream.write
  413.         indent += self._indent_per_level
  414.         if self._indent_per_level > 1:
  415.             write((self._indent_per_level - 1) * ' ')
  416.         delimnl = ',\n' + ' ' * indent
  417.         delim = ''
  418.         width = max_width = self._width - indent + 1
  419.         it = iter(items)
  420.         try:
  421.             next_ent = next(it)
  422.         except StopIteration:
  423.             return
  424.         last = False
  425.         while not last:
  426.             ent = next_ent
  427.             try:
  428.                 next_ent = next(it)
  429.             except StopIteration:
  430.                 last = True
  431.                 max_width -= allowance
  432.                 width -= allowance
  433.             if self._compact:
  434.                 rep = self._repr(ent, context, level)
  435.                 w = len(rep) + 2
  436.                 if width < w:
  437.                     width = max_width
  438.                     if delim:
  439.                         delim = delimnl
  440.                 if width >= w:
  441.                     width -= w
  442.                     write(delim)
  443.                     delim = ', '
  444.                     write(rep)
  445.                     continue
  446.             write(delim)
  447.             delim = delimnl
  448.             self._format(ent, stream, indent,
  449.                          allowance if last else 1,
  450.                          context, level)
  452.     def _repr(self, object, context, level):
  453.         repr, readable, recursive = self.format(object, context.copy(),
  454.                                                 self._depth, level)
  455.         if not readable:
  456.             self._readable = False
  457.         if recursive:
  458.             self._recursive = True
  459.         return repr
  461.     def format(self, object, context, maxlevels, level):
  462.         """Format object for a specific context, returning a string
  463.         and flags indicating whether the representation is 'readable'
  464.         and whether the object represents a recursive construct.
  465.         """
  466.         return self._safe_repr(object, context, maxlevels, level)
  468.     def _pprint_default_dict(self, object, stream, indent, allowance, context, level):
  469.         if not len(object):
  470.             stream.write(repr(object))
  471.             return
  472.         rdf = self._repr(object.default_factory, context, level)
  473.         cls = object.__class__
  474.         indent += len(cls.__name__) + 1
  475.         stream.write('%s(%s,\n%s' % (cls.__name__, rdf, ' ' * indent))
  476.         self._pprint_dict(object, stream, indent, allowance + 1, context, level)
  477.         stream.write(')')
  479.     _dispatch[_collections.defaultdict.__repr__] = _pprint_default_dict
  481.     def _pprint_counter(self, object, stream, indent, allowance, context, level):
  482.         if not len(object):
  483.             stream.write(repr(object))
  484.             return
  485.         cls = object.__class__
  486.         stream.write(cls.__name__ + '({')
  487.         if self._indent_per_level > 1:
  488.             stream.write((self._indent_per_level - 1) * ' ')
  489.         items = object.most_common()
  490.         self._format_dict_items(items, stream,
  491.                                 indent + len(cls.__name__) + 1, allowance + 2,
  492.                                 context, level)
  493.         stream.write('})')
  495.     _dispatch[_collections.Counter.__repr__] = _pprint_counter
  497.     def _pprint_chain_map(self, object, stream, indent, allowance, context, level):
  498.         if not len(object.maps):
  499.             stream.write(repr(object))
  500.             return
  501.         cls = object.__class__
  502.         stream.write(cls.__name__ + '(')
  503.         indent += len(cls.__name__) + 1
  504.         for i, m in enumerate(object.maps):
  505.             if i == len(object.maps) - 1:
  506.                 self._format(m, stream, indent, allowance + 1, context, level)
  507.                 stream.write(')')
  508.             else:
  509.                 self._format(m, stream, indent, 1, context, level)
  510.                 stream.write(',\n' + ' ' * indent)
  512.     _dispatch[_collections.ChainMap.__repr__] = _pprint_chain_map
  514.     def _pprint_deque(self, object, stream, indent, allowance, context, level):
  515.         if not len(object):
  516.             stream.write(repr(object))
  517.             return
  518.         cls = object.__class__
  519.         stream.write(cls.__name__ + '(')
  520.         indent += len(cls.__name__) + 1
  521.         stream.write('[')
  522.         if object.maxlen is None:
  523.             self._format_items(object, stream, indent, allowance + 2,
  524.                                context, level)
  525.             stream.write('])')
  526.         else:
  527.             self._format_items(object, stream, indent, 2,
  528.                                context, level)
  529.             rml = self._repr(object.maxlen, context, level)
  530.             stream.write('],\n%smaxlen=%s)' % (' ' * indent, rml))
  532.     _dispatch[_collections.deque.__repr__] = _pprint_deque
  534.     def _pprint_user_dict(self, object, stream, indent, allowance, context, level):
  535.         self._format(object.data, stream, indent, allowance, context, level - 1)
  537.     _dispatch[_collections.UserDict.__repr__] = _pprint_user_dict
  539.     def _pprint_user_list(self, object, stream, indent, allowance, context, level):
  540.         self._format(object.data, stream, indent, allowance, context, level - 1)
  542.     _dispatch[_collections.UserList.__repr__] = _pprint_user_list
  544.     def _pprint_user_string(self, object, stream, indent, allowance, context, level):
  545.         self._format(object.data, stream, indent, allowance, context, level - 1)
  547.     _dispatch[_collections.UserString.__repr__] = _pprint_user_string
  549.     def _safe_repr(self, object, context, maxlevels, level):
  550.         # Return triple (repr_string, isreadable, isrecursive).
  551.         typ = type(object)
  552.         if typ in _builtin_scalars:
  553.             return repr(object), True, False
  555.         r = getattr(typ, "__repr__", None)
  557.         if issubclass(typ, int) and r is int.__repr__:
  558.             if self._underscore_numbers:
  559.                 return f"{object:_d}", True, False
  560.             else:
  561.                 return repr(object), True, False
  563.         if issubclass(typ, dict) and r is dict.__repr__:
  564.             if not object:
  565.                 return "{}", True, False
  566.             objid = id(object)
  567.             if maxlevels and level >= maxlevels:
  568.                 return "{...}", False, objid in context
  569.             if objid in context:
  570.                 return _recursion(object), False, True
  571.             context[objid] = 1
  572.             readable = True
  573.             recursive = False
  574.             components = []
  575.             append = components.append
  576.             level += 1
  577.             if self._sort_dicts:
  578.                 items = sorted(object.items(), key=_safe_tuple)
  579.             else:
  580.                 items = object.items()
  581.             for k, v in items:
  582.                 krepr, kreadable, krecur = self.format(
  583.                     k, context, maxlevels, level)
  584.                 vrepr, vreadable, vrecur = self.format(
  585.                     v, context, maxlevels, level)
  586.                 append("%s: %s" % (krepr, vrepr))
  587.                 readable = readable and kreadable and vreadable
  588.                 if krecur or vrecur:
  589.                     recursive = True
  590.             del context[objid]
  591.             return "{%s}" % ", ".join(components), readable, recursive
  593.         if (issubclass(typ, list) and r is list.__repr__) or \
  594.            (issubclass(typ, tuple) and r is tuple.__repr__):
  595.             if issubclass(typ, list):
  596.                 if not object:
  597.                     return "[]", True, False
  598.                 format = "[%s]"
  599.             elif len(object) == 1:
  600.                 format = "(%s,)"
  601.             else:
  602.                 if not object:
  603.                     return "()", True, False
  604.                 format = "(%s)"
  605.             objid = id(object)
  606.             if maxlevels and level >= maxlevels:
  607.                 return format % "...", False, objid in context
  608.             if objid in context:
  609.                 return _recursion(object), False, True
  610.             context[objid] = 1
  611.             readable = True
  612.             recursive = False
  613.             components = []
  614.             append = components.append
  615.             level += 1
  616.             for o in object:
  617.                 orepr, oreadable, orecur = self.format(
  618.                     o, context, maxlevels, level)
  619.                 append(orepr)
  620.                 if not oreadable:
  621.                     readable = False
  622.                 if orecur:
  623.                     recursive = True
  624.             del context[objid]
  625.             return format % ", ".join(components), readable, recursive
  627.         rep = repr(object)
  628.         return rep, (rep and not rep.startswith('<')), False
  630. _builtin_scalars = frozenset({str, bytes, bytearray, float, complex,
  631.                               bool, type(None)})
  633. def _recursion(object):
  634.     return ("<Recursion on %s with id=%s>"
  635.             % (type(object).__name__, id(object)))
  638. def _perfcheck(object=None):
  639.     import time
  640.     if object is None:
  641.         object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000
  642.     p = PrettyPrinter()
  643.     t1 = time.perf_counter()
  644.     p._safe_repr(object, {}, None, 0, True)
  645.     t2 = time.perf_counter()
  646.     p.pformat(object)
  647.     t3 = time.perf_counter()
  648.     print("_safe_repr:", t2 - t1)
  649.     print("pformat:", t3 - t2)
  651. def _wrap_bytes_repr(object, width, allowance):
  652.     current = b''
  653.     last = len(object) // 4 * 4
  654.     for i in range(0, len(object), 4):
  655.         part = object[i: i+4]
  656.         candidate = current + part
  657.         if i == last:
  658.             width -= allowance
  659.         if len(repr(candidate)) > width:
  660.             if current:
  661.                 yield repr(current)
  662.             current = part
  663.         else:
  664.             current = candidate
  665.     if current:
  666.         yield repr(current)
  668. if __name__ == "__main__":
  669.     _perfcheck()