python · hongweipeng · May 4, 2020 · May 5, 2020 · May 5, 2020 · May 5, 2020
diff --git a/Doc/library/enum.rst b/Doc/library/enum.rst
@@ -273,10 +273,6 @@ overridden::
     the next :class:`int` in sequence with the last :class:`int` provided, but
     the way it does this is an implementation detail and may change.
 
-.. note::
-
-    The :meth:`_generate_next_value_` method must be defined before any members.
-
 Iteration
 ---------
 

diff --git a/Lib/enum.py b/Lib/enum.py
@@ -60,7 +60,7 @@ def __init__(self):
         self._member_names = []
         self._last_values = []
         self._ignore = []
-        self._auto_called = False
+        self._subclass_define_generate_next_value = False
 
     def __setitem__(self, key, value):
         """Changes anything not dundered or not a descriptor.
@@ -78,10 +78,9 @@ def __setitem__(self, key, value):
                     ):
                 raise ValueError('_names_ are reserved for future Enum use')
             if key == '_generate_next_value_':
-                # check if members already defined as auto()
-                if self._auto_called:
-                    raise TypeError("_generate_next_value_ must be defined before members")
                 setattr(self, '_generate_next_value', value)
+                if value is not getattr(Enum, '_generate_next_value_', None):
+                    self._subclass_define_generate_next_value = True
             elif key == '_ignore_':
                 if isinstance(value, str):
                     value = value.replace(',',' ').split()
@@ -104,10 +103,9 @@ def __setitem__(self, key, value):
                 # enum overwriting a descriptor?
                 raise TypeError('%r already defined as: %r' % (key, self[key]))
             if isinstance(value, auto):
-                self._auto_called = True
-                if value.value == _auto_null:
+                if value.value is _auto_null and self._subclass_define_generate_next_value:
                     value.value = self._generate_next_value(key, 1, len(self._member_names), self._last_values[:])
-                value = value.value
+                    value = value.value
             self._member_names.append(key)
             self._last_values.append(value)
         super().__setitem__(key, value)
@@ -146,6 +144,15 @@ def __new__(metacls, cls, bases, classdict):
         __new__, save_new, use_args = metacls._find_new_(classdict, member_type,
                                                         first_enum)
 
+        # calculate the value of auto()
+        for i, name in enumerate(classdict._member_names):
+            _value = classdict._last_values[i]
+            if isinstance(_value, auto):
+                if _value.value is _auto_null:
+                    _value.value = classdict._generate_next_value(name, 1, i, classdict._last_values[:i])
+                    classdict._last_values[i] = _value.value
+                super(type(classdict), classdict).__setitem__(name, _value.value)
+
         # save enum items into separate mapping so they don't get baked into
         # the new class
         enum_members = {k: classdict[k] for k in classdict._member_names}

diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
@@ -1751,14 +1751,34 @@ class Color(Enum):
         self.assertEqual(Color.blue.value, 2)
         self.assertEqual(Color.green.value, 3)
 
-    def test_auto_order(self):
+    def test_auto_generate_next_value(self):
+        class E(Enum):
+            A = auto()
+            B = auto()
+            def _generate_next_value_(name, *args):
+                return name
+
+        class F(Enum):
+            def _generate_next_value_(name, *args):
+                return name
+            A = auto()
+            B = auto()
+
+        class G(Enum):
+            def _generate_next_value_(name, *args):
+                return 12
+            first = auto()
+            second = first + 9
+
         with self.assertRaises(TypeError):
-            class Color(Enum):
-                red = auto()
-                green = auto()
-                blue = auto()
-                def _generate_next_value_(name, start, count, last):
-                    return name
+            class H(Enum):
+                first = auto()
+                def _generate_next_value_(name, *args):
+                    return 12
+                second = first + 9
+
+        self.assertEqual(E.B.value, F.B.value)
+        self.assertEqual(G.second.value, 21)
 
 
     def test_duplicate_auto(self):

diff --git a/Misc/ACKS b/Misc/ACKS
@@ -732,6 +732,7 @@ Thomas Holmes
 Craig Holmquist
 Philip Homburg
 Naofumi Honda
+Weipeng Hong
 Jeffrey Honig
 Rob Hooft
 Michiel de Hoon

diff --git a/Misc/NEWS.d/next/Library/2020-05-05-00-29-29.bpo-40025.Divf9C.rst b/Misc/NEWS.d/next/Library/2020-05-05-00-29-29.bpo-40025.Divf9C.rst
@@ -0,0 +1,2 @@
+The behavior is the same when `_generate_next_value_` is defined after or
+before members. Patch by Weipeng Hong.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		The behavior is the same when `_generate_next_value_` is defined after or
		before members. Patch by Weipeng Hong.