You can alter the output of pprint, but you need to re-implement the saferepr() function, not just subclass the pprint.PrettyPrinter() class.
What happens is that (an internal version of) the saferepr() function is used for all objects, and that function itself then recursively handles turning objects into representations (using only itself, not the PrettyPrinter() instance), so any customisation has to happen there. Only when the result of saferepr() becomes too large (too wide for the configured width) will the PrettyPrinter class start breaking up container output into components to put on separate lines; the process of calling saferepr() is then repeated for the component elements.
So PrettyPrinter.format() is only responsible for handling the top-level object, and every recursive object that is a) inside a supported container type (dict, list, tuple, string and the standard library subclasses of these) and b) where the representation of the parent container produced by .format() exceeded the display width.
To be able to override the implementation, we need to understand how the .format() method and the saferepr() implementation interact, what arguments they take and what they need to return.
PrettyPrinter.format() is passed additional arguments, context, maxlevels and level:
context is used to detect recursion (the default implementation returns the result of _recursion(object) if id(object) in context is true.- when
maxlevels is set and level >= maxlevels is true, the default implementation returns ... as the contents of a container.
The method is also supposed to return a tuple of 3 values; the representation string and two flags. You can safely ignore the meaning of those flags, they are actually never used in the current implementation. They are meant to signal if the produced representation is 'readable' (uses Python syntax that can be passed to eval()) or was recursive (the object contained circular references). But the PrettyPrinter.isreadable() and PrettyPrinter.isrecursive() methodsactually completely bypass .format(); these return values seem to be a hold-over from a refactoring that broke the relationship between .format() and those two methods. So just return a representation string and whatever two boolean values you like.
.format() really just delegates to an internal implementation of saferepr() that then does several things
- handle recursion detection with
context, and depth handling for maxlevels and level
- recurse over dictionaries, lists and tuples (and their subclasses, as long as their
__repr__ method is still the default implementation)
- for dictionaries, sort the key-value pairs. This is trickier than it appears in Python 3, but this is solved with a custom
_safe_tuple sorting key that approximates Python 2's sort everything behaviour. We can re-use this.
To implement a recursive replacement, I prefer to use @functools.singledispatch() to delegate handling of different types. Ignoring custom __repr__ methods, handling depth issues, recursion, and empty objects, can also be handled by a decorator:
import pprint
from pprint import PrettyPrinter
from functools import singledispatch, wraps
from typing import get_type_hints
def common_container_checks(f):
type_ = get_type_hints(f)['object']
base_impl = type_.__repr__
empty_repr = repr(type_()) # {}, [], ()
too_deep_repr = f'{empty_repr[0]}...{empty_repr[-1]}' # {...}, [...], (...)
@wraps(f)
def wrapper(object, context, maxlevels, level):
if type(object).__repr__ is not base_impl: # subclassed repr
return repr(object)
if not object: # empty, short-circuit
return empty_repr
if maxlevels and level >= maxlevels: # exceeding the max depth
return too_deep_repr
oid = id(object)
if oid in context: # self-reference
return pprint._recursion(object)
context[oid] = 1
result = f(object, context, maxlevels, level)
del context[oid]
return result
return wrapper
@singledispatch
def saferepr(object, context, maxlevels, level):
return repr(object)
@saferepr.register
def _handle_int(object: int, *args):
# uppercase hexadecimal representation with 0x prefix
return f'0x{object:X}'
@saferepr.register
@common_container_checks
def _handle_dict(object: dict, context, maxlevels, level):
level += 1
contents = [
f'{saferepr(k, context, maxlevels, level)}: '
f'{saferepr(v, context, maxlevels, level)}'
for k, v in sorted(object.items(), key=pprint._safe_tuple)
]
return f'{{{", ".join(contents)}}}'
@saferepr.register
@common_container_checks
def _handle_list(object: list, context, maxlevels, level):
level += 1
contents = [
f'{saferepr(v, context, maxlevels, level)}'
for v in object
]
return f'[{", ".join(contents)}]'
@saferepr.register
@common_container_checks
def _handle_tuple(object: tuple, context, maxlevels, level):
level += 1
if len(object) == 1:
return f'({saferepr(object[0], context, maxlevels, level)},)'
contents = [
f'{saferepr(v, context, maxlevels, level)}'
for v in object
]
return f'({", ".join(contents)})'
class HexIntPrettyPrinter(PrettyPrinter):
def format(self, *args):
# it doesn't matter what the boolean values are here
return saferepr(*args), True, False
This hand-full can handle anything the base pprint implementation can, and it will produce hex integers in any supported container. Just create an instance of the HexIntPrettyPrinter() class and call .pprint() on that:
>>> sample = {66: 'far',
... 99: 'Bottles of the beer on the wall',
... '12': 4277009102,
... 'boo': 21,
... 'pprint': [16, 32, 48, 64, 80, 96, 112, 128]}
>>> pprinter = HexIntPrettyPrinter()
>>> pprinter.pprint(sample)
{0x42: 'far',
0x63: 'Bottles of the beer on the wall',
'12': 0xFEEDFACE,
'boo': 0x15,
'pprint': [0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80]}
Side note: if you are using Python 3.6 or older you'll have to replace the @saferepr.registration lines with @saferepr.registration(<type>) calls, where <type> duplicates the type annotation on the first argument of the registered function.
