string.Formatter: unnumbered key/attributes access

Fixes: python#27307

Author: qm2k

Lib/string.py

@@ -186,19 +186,41 @@ def get_identifiers(self):
 # The field name parser is implemented in _string.formatter_field_name_split
 
 class Formatter:
+
+    class AutoNumber:
+        def __init__(self):
+            self.field_number = 0
+
+        def __next__(self):
+            if self.field_number is False:
+                raise ValueError('cannot switch from manual field '
+                                 'specification to automatic field '
+                                 'numbering')
+            self.field_number += 1
+            return self.field_number - 1
+
+        def set_manual(self):
+            if self.field_number:
+                raise ValueError('cannot switch from automatic '
+                                 'field numbering to manual '
+                                 'field specification')
+            self.field_number = False
+
     def format(self, format_string, /, *args, **kwargs):
         return self.vformat(format_string, args, kwargs)
 
     def vformat(self, format_string, args, kwargs):
         used_args = set()
-        result, _ = self._vformat(format_string, args, kwargs, used_args, 2)
+        result = self._vformat(format_string, args, kwargs, used_args, 2)
         self.check_unused_args(used_args, args, kwargs)
         return result
 
     def _vformat(self, format_string, args, kwargs, used_args, recursion_depth,
-                 auto_arg_index=0):
+                 auto_number=None):
         if recursion_depth < 0:
             raise ValueError('Max string recursion exceeded')
+        if not auto_number:
+            auto_number = Formatter.AutoNumber()
         result = []
         for literal_text, field_name, format_spec, conversion in \
                 self.parse(format_string):
@@ -212,22 +234,8 @@ def _vformat(self, format_string, args, kwargs, used_args, recursion_depth,
                 # this is some markup, find the object and do
                 #  the formatting
 
-                # handle arg indexing when empty field_names are given.
-                if field_name == '':
-                    if auto_arg_index is False:
-                        raise ValueError('cannot switch from manual field '
-                                         'specification to automatic field '
-                                         'numbering')
-                    field_name = str(auto_arg_index)
-                    auto_arg_index += 1
-                elif field_name.isdigit():
-                    if auto_arg_index:
-                        raise ValueError('cannot switch from manual field '
-                                         'specification to automatic field '
-                                         'numbering')
-                    # disable auto arg incrementing, if it gets
-                    # used later on, then an exception will be raised
-                    auto_arg_index = False
+                field_name = self.ensure_reference(field_name,
+                    auto_number)
 
                 # given the field_name, find the object it references
                 #  and the argument it came from
@@ -238,15 +246,15 @@ def _vformat(self, format_string, args, kwargs, used_args, recursion_depth,
                 obj = self.convert_field(obj, conversion)
 
                 # expand the format spec, if needed
-                format_spec, auto_arg_index = self._vformat(
+                format_spec = self._vformat(
                     format_spec, args, kwargs,
                     used_args, recursion_depth-1,
-                    auto_arg_index=auto_arg_index)
+                    auto_number)
 
                 # format the object and append to the result
                 result.append(self.format_field(obj, format_spec))
 
-        return ''.join(result), auto_arg_index
+        return ''.join(result)
 
 
     def get_value(self, key, args, kwargs):
@@ -288,6 +296,23 @@ def parse(self, format_string):
         return _string.formatter_parser(format_string)
 
 
+    # given a field_name and auto_number, return a version
+    # starting with a name or index, taken from auto_number
+    # if necessary; calls auto_number.set_manual()
+    # if field_name already contains index
+    #  field_name:   the field being checked, e.g. "",
+    #                ".name" or "[3]"
+    #  auto_number   numbering source
+    def ensure_reference(self, field_name, auto_number):
+        first, _ = _string.formatter_field_name_split(field_name)
+        if first == '':
+            first = str(next(auto_number))
+            field_name = first + field_name
+        elif isinstance(first, int):
+            auto_number.set_manual()
+        return field_name
+
+
     # given a field_name, find the object it references.
     #  field_name:   the field being looked up, e.g. "0.name"
     #                 or "lookup[3]"

Lib/test/test_string.py

@@ -1,6 +1,7 @@
 import unittest
 import string
 from string import Template
+import types
 
 
 class ModuleTest(unittest.TestCase):
@@ -101,6 +102,22 @@ def test_index_lookup(self):
         with self.assertRaises(KeyError):
             fmt.format("{0[2]}{0[0]}", {})
 
+    def test_auto_numbering_lookup(self):
+        fmt = string.Formatter()
+        namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz'))
+        widths = [None, types.SimpleNamespace(qux=4)]
+        self.assertEqual(
+            fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ')
+
+    def test_auto_numbering_reenterability(self):
+        class ReenteringFormatter(string.Formatter):
+            def format_field(self, value, format_spec):
+                return (self.format(' {:{}} ', value, int(format_spec) - 1)
+                    if format_spec.isdigit() and int(format_spec) > 0
+                    else super().format_field(value, format_spec))
+        fmt = ReenteringFormatter()
+        self.assertEqual(fmt.format("{:{}}", 42, 5), '     42     ')
+
     def test_override_get_value(self):
         class NamespaceFormatter(string.Formatter):
             def __init__(self, namespace={}):