feat(gh-145056): Support frozendict in reprlib

- Add Repr.repr_frozendict() sharing _repr_mapping() with repr_dict()
- frozendict reprs were cut in the middle instead of abbreviated by item
- Register frozendict in Repr._lookup so shadowed names are not matched

Author: skippdot

Lib/reprlib.py

@@ -44,6 +44,7 @@ class Repr:
         'frozenset': 'builtins',
         'deque': 'collections',
         'dict': 'builtins',
+        'frozendict': 'builtins',
         'str': 'builtins',
         'int': 'builtins'
     }
@@ -153,12 +154,10 @@ def repr_frozenset(self, x, level):
     def repr_deque(self, x, level):
         return self._repr_iterable(x, level, 'deque([', '])', self.maxdeque)
 
-    def repr_dict(self, x, level):
+    def _repr_mapping(self, x, level, left, right):
         n = len(x)
-        if n == 0:
-            return '{}'
         if level <= 0:
-            return '{' + self.fillvalue + '}'
+            return left + self.fillvalue + right
         newlevel = level - 1
         repr1 = self.repr1
         pieces = []
@@ -169,7 +168,17 @@ def repr_dict(self, x, level):
         if n > self.maxdict:
             pieces.append(self.fillvalue)
         s = self._join(pieces, level)
-        return '{%s}' % (s,)
+        return '%s%s%s' % (left, s, right)
+
+    def repr_dict(self, x, level):
+        if not x:
+            return '{}'
+        return self._repr_mapping(x, level, '{', '}')
+
+    def repr_frozendict(self, x, level):
+        if not x:
+            return 'frozendict()'
+        return self._repr_mapping(x, level, 'frozendict({', '})')
 
     def repr_str(self, x, level):
         s = builtins.repr(x[:self.maxstring])

Lib/test/test_reprlib.py

@@ -126,6 +126,14 @@ def test_container(self):
         d['arthur'] = 1
         eq(r(d), "{'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...}")
 
+        # Frozendicts give up after 4 as well.
+        eq(r(frozendict()), "frozendict()")
+        d = frozendict(alice=1, bob=2, charles=3, dave=4)
+        eq(r(d), "frozendict({'alice': 1, 'bob': 2, 'charles': 3, 'dave': 4})")
+        d |= {'arthur': 1}
+        eq(r(d),
+           "frozendict({'alice': 1, 'arthur': 1, 'bob': 2, 'charles': 3, ...})")
+
         # array.array after 5.
         eq(r(array('i')), "array('i')")
         eq(r(array('i', [1])), "array('i', [1])")
@@ -150,6 +158,25 @@ def test_frozenset(self):
         eq(r(frozenset({1, 2, 3, 4, 5, 6})), "frozenset({1, 2, 3, 4, 5, 6})")
         eq(r(frozenset({1, 2, 3, 4, 5, 6, 7})), "frozenset({1, 2, 3, 4, 5, 6, ...})")
 
+    def test_frozendict(self):
+        eq = self.assertEqual
+        eq(r(frozendict({1: 1})), "frozendict({1: 1})")
+        eq(r(frozendict({1: 1, 2: 2, 3: 3})), "frozendict({1: 1, 2: 2, 3: 3})")
+        eq(r(frozendict({1: 1, 2: 2, 3: 3, 4: 4})),
+           "frozendict({1: 1, 2: 2, 3: 3, 4: 4})")
+        eq(r(frozendict({1: 1, 2: 2, 3: 3, 4: 4, 5: 5})),
+           "frozendict({1: 1, 2: 2, 3: 3, 4: 4, ...})")
+
+        # Keys are sorted and values are abbreviated, as for dict
+        eq(r(frozendict({3: 'c', 1: 'a' * 40, 2: 'b'})),
+           "frozendict({1: 'aaaaaaaaaaaa...aaaaaaaaaaaaa', 2: 'b', 3: 'c'})")
+
+        # The limit is shared with dict
+        r2 = Repr(maxdict=2)
+        eq(r2.repr(frozendict({1: 1, 2: 2})), "frozendict({1: 1, 2: 2})")
+        eq(r2.repr(frozendict({1: 1, 2: 2, 3: 3})),
+           "frozendict({1: 1, 2: 2, ...})")
+
     def test_numbers(self):
         for x in [123, 1.0 / 3]:
             self.assertEqual(r(x), repr(x))
@@ -237,6 +264,12 @@ def test_nesting(self):
         eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]")
         eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]")
 
+        r1 = Repr(maxlevel=1)
+        eq(r1.repr(frozendict({1: frozendict()})),
+           "frozendict({1: frozendict()})")
+        eq(r1.repr(frozendict({1: frozendict({2: 3})})),
+           "frozendict({1: frozendict({...})})")
+
     def test_cell(self):
         def get_cell():
             x = 42
@@ -269,9 +302,11 @@ def test_unsortable(self):
         x = set([1j, 2j, 3j])
         y = frozenset(x)
         z = {1j: 1, 2j: 2}
+        w = frozendict(z)
         r(x)
         r(y)
         r(z)
+        r(w)
 
     def test_valid_indent(self):
         test_cases = [
@@ -574,6 +609,32 @@ def test_valid_indent(self):
                         }'''),
                 ),
             },
+            {
+                'object': frozendict({1: 'two', b'three': frozendict({4: 5})}),
+                'tests': (
+                    (dict(indent=None), '''\
+                        frozendict({1: 'two', b'three': frozendict({4: 5})})'''),
+                    (dict(indent=4), '''\
+                        frozendict({
+                            1: 'two',
+                            b'three': frozendict({
+                                4: 5,
+                            }),
+                        })'''),
+                    (dict(indent=4, maxlevel=1), '''\
+                        frozendict({
+                            1: 'two',
+                            b'three': frozendict({...}),
+                        })'''),
+                    (dict(indent='-->'), '''\
+                        frozendict({
+                        -->1: 'two',
+                        -->b'three': frozendict({
+                        -->-->4: 5,
+                        -->}),
+                        })'''),
+                ),
+            },
         ]
         for test_case in test_cases:
             with self.subTest(test_object=test_case['object']):
@@ -622,6 +683,13 @@ def __repr__(self):
 
         self.assertEqual(r(list()), "not builtins.list")
 
+    def test_shadowed_frozendict(self):
+        class frozendict:
+            def __repr__(self):
+                return "not builtins.frozendict"
+
+        self.assertEqual(r(frozendict()), "not builtins.frozendict")
+
     def test_custom_repr(self):
         class MyRepr(Repr):
 

Misc/NEWS.d/next/Library/2026-10-13-18-46-25.gh-issue-145056.rPrFzD.rst

@@ -0,0 +1,3 @@
+:func:`reprlib.repr` and :class:`reprlib.Repr` now abbreviate
+:class:`frozendict` instances by item, like :class:`dict`, using the
+:attr:`~reprlib.Repr.maxdict` limit.