Use a rich.pretty compatible pretty printer API

Author: warsaw

Lib/pprint.py

@@ -609,14 +609,50 @@ def _pprint_user_string(self, object, stream, indent, allowance, context, level)
 
     _dispatch[_collections.UserString.__repr__] = _pprint_user_string
 
+    def _format_pprint(self, object, method, context, maxlevels, level):
+        """Format an object using its __pprint__ method.
+
+        The __pprint__ method should be a generator yielding values:
+           - yield value                  -> positional arg
+           - yield (name, value)          -> keyword arg, always shown
+           - yield (name, value, default) -> keyword arg, shown if value != default
+        """
+        cls_name = type(object).__name__
+        parts = []
+        readable = True
+
+        for item in method(object):
+            if isinstance(item, tuple):
+                if len(item) == 2:
+                    # (name, value) - always show
+                    name, value = item
+                    vrep, vreadable, _ = self.format(value, context, maxlevels, level + 1)
+                    parts.append(f"{name}={vrep}")
+                    readable = readable and vreadable
+                elif len(item) == 3:
+                    # (name, value, default) - show only if value != default
+                    name, value, default = item
+                    if value != default:
+                        vrep, vreadable, _ = self.format(value, context, maxlevels, level + 1)
+                        parts.append(f"{name}={vrep}")
+                        readable = readable and vreadable
+            else:
+                # Positional argument
+                vrep, vreadable, _ = self.format(item, context, maxlevels, level + 1)
+                parts.append(vrep)
+                readable = readable and vreadable
+
+        rep = f"{cls_name}({', '.join(parts)})"
+        return rep, readable, False
+
     def _safe_repr(self, object, context, maxlevels, level):
         # Return triple (repr_string, isreadable, isrecursive).
         typ = type(object)
         if typ in _builtin_scalars:
             return repr(object), True, False
 
         if (p := getattr(typ, "__pprint__", None)):
-            return p(object, context, maxlevels, level)
+            return self._format_pprint(object, p, context, maxlevels, level)
 
         r = getattr(typ, "__repr__", None)
 

Lib/test/test_pprint.py

@@ -136,15 +136,19 @@ def __hash__(self):
 
 
 class CustomPrintable:
+    def __init__(self, name="my pprint", value=42):
+        self.name = name
+        self.value = value
+
     def __str__(self):
         return "my str"
 
     def __repr__(self):
         return "my str"
 
-    def __pprint__(self, context, maxlevels, level):
-        # The custom pretty repr, not-readable bool, no recursion detected.
-        return "my pprint", False, False
+    def __pprint__(self):
+        yield self.name
+        yield ("value", self.value)
 
 
 class QueryTestCase(unittest.TestCase):
@@ -1490,7 +1494,72 @@ def test_custom_pprinter(self):
         pp = pprint.PrettyPrinter(stream=stream)
         custom_obj = CustomPrintable()
         pp.pprint(custom_obj)
-        self.assertEqual(stream.getvalue(), "my pprint\n")
+        self.assertEqual(stream.getvalue(), "CustomPrintable('my pprint', value=42)\n")
+
+    def test_pprint_protocol_positional(self):
+        # Test __pprint__ with positional arguments only
+        class Point:
+            def __init__(self, x, y):
+                self.x = x
+                self.y = y
+            def __pprint__(self):
+                yield self.x
+                yield self.y
+        self.assertEqual(pprint.pformat(Point(1, 2)), "Point(1, 2)")
+
+    def test_pprint_protocol_keyword(self):
+        # Test __pprint__ with keyword arguments
+        class Config:
+            def __init__(self, host, port):
+                self.host = host
+                self.port = port
+            def __pprint__(self):
+                yield ("host", self.host)
+                yield ("port", self.port)
+        self.assertEqual(pprint.pformat(Config("localhost", 8080)),
+                         "Config(host='localhost', port=8080)")
+
+    def test_pprint_protocol_default(self):
+        # Test __pprint__ with default values (3-tuple form)
+        class Bird:
+            def __init__(self, name, fly=True, extinct=False):
+                self.name = name
+                self.fly = fly
+                self.extinct = extinct
+            def __pprint__(self):
+                yield self.name
+                yield ("fly", self.fly, True)       # hide if True
+                yield ("extinct", self.extinct, False)  # hide if False
+
+        # Defaults should be hidden
+        self.assertEqual(pprint.pformat(Bird("sparrow")),
+                         "Bird('sparrow')")
+        # Non-defaults should be shown
+        self.assertEqual(pprint.pformat(Bird("dodo", fly=False, extinct=True)),
+                         "Bird('dodo', fly=False, extinct=True)")
+
+    def test_pprint_protocol_nested(self):
+        # Test __pprint__ with nested objects
+        class Container:
+            def __init__(self, items):
+                self.items = items
+            def __pprint__(self):
+                yield ("items", self.items)
+        c = Container([1, 2, 3])
+        self.assertEqual(pprint.pformat(c), "Container(items=[1, 2, 3])")
+        # Nested in a list
+        self.assertEqual(pprint.pformat([c]), "[Container(items=[1, 2, 3])]")
+
+    def test_pprint_protocol_isreadable(self):
+        # Test that isreadable works correctly with __pprint__
+        class Readable:
+            def __pprint__(self):
+                yield 42
+        class Unreadable:
+            def __pprint__(self):
+                yield open  # built-in function, not readable
+        self.assertTrue(pprint.isreadable(Readable()))
+        self.assertFalse(pprint.isreadable(Unreadable()))
 
 
 class DottedPrettyPrinter(pprint.PrettyPrinter):

Lib/test/test_print.py

@@ -202,8 +202,8 @@ def test_string_in_loop_on_same_line(self):
 
 
 class PPrintable:
-    def __pprint__(self, context, maxlevels, level):
-        return 'I feel pretty', False, False
+    def __pprint__(self):
+        yield 'I feel pretty'
 
 
 class PrettySmart(PrettyPrinter):
@@ -229,11 +229,11 @@ def test_default_pretty_printer(self):
 
     def test_pprint_magic(self):
         print('one', PPrintable(), 2, file=self.file, pretty=True)
-        self.assertEqual(self.file.getvalue(), "'one' I feel pretty 2\n")
+        self.assertEqual(self.file.getvalue(), "'one' PPrintable('I feel pretty') 2\n")
 
     def test_custom_pprinter(self):
         print('one', PPrintable(), 2, file=self.file, pretty=PrettySmart())
-        self.assertEqual(self.file.getvalue(), "one I feel pretty 2\n")
+        self.assertEqual(self.file.getvalue(), "one PPrintable('I feel pretty') 2\n")
 
     def test_bad_pprinter(self):
         with self.assertRaises(AttributeError):