diff options
| -rw-r--r-- | Doc/library/enum.rst | 4 | ||||
| -rw-r--r-- | Lib/enum.py | 34 | ||||
| -rw-r--r-- | Lib/test/test_enum.py | 65 | ||||
| -rw-r--r-- | Misc/NEWS.d/next/Library/2022-04-11-16-55-41.gh-issue-91456.DK3KKl.rst | 3 |
4 files changed, 89 insertions, 17 deletions
diff --git a/Doc/library/enum.rst b/Doc/library/enum.rst index c3256c5..b1333c7 100644 --- a/Doc/library/enum.rst +++ b/Doc/library/enum.rst @@ -761,6 +761,10 @@ Utilities and Decorators ``_generate_next_value_`` can be overridden to customize the values used by *auto*. + .. note:: in 3.13 the default ``"generate_next_value_`` will always return + the highest member value incremented by 1, and will fail if any + member is an incompatible type. + .. decorator:: property A decorator similar to the built-in *property*, but specifically for diff --git a/Lib/enum.py b/Lib/enum.py index decb601..8d0982a 100644 --- a/Lib/enum.py +++ b/Lib/enum.py @@ -1205,21 +1205,39 @@ class Enum(metaclass=EnumType): def __init__(self, *args, **kwds): pass - def _generate_next_value_(name, start, count, last_values): + def _generate_next_value_(name, start, count, last_value): """ Generate the next value when not given. name: the name of the member start: the initial start value or None count: the number of existing members - last_value: the last value assigned or None + last_value: the list of values assigned """ - for last_value in reversed(last_values): - try: - return last_value + 1 - except TypeError: - pass - else: + if not last_value: + return start + try: + last = last_value[-1] + last_value.sort() + if last == last_value[-1]: + # no difference between old and new methods + return last + 1 + else: + # trigger old method (with warning) + raise TypeError + except TypeError: + import warnings + warnings.warn( + "In 3.13 the default `auto()`/`_generate_next_value_` will require all values to be sortable and support adding +1\n" + "and the value returned will be the largest value in the enum incremented by 1", + DeprecationWarning, + stacklevel=3, + ) + for v in last_value: + try: + return v + 1 + except TypeError: + pass return start @classmethod diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py index e26ef00..528ec0d 100644 --- a/Lib/test/test_enum.py +++ b/Lib/test/test_enum.py @@ -3953,23 +3953,54 @@ class TestInternals(unittest.TestCase): self.assertEqual(Color.blue.value, 'blue') self.assertEqual(Color.green.value, 'green') - def test_auto_garbage(self): - class Color(Enum): - red = 'red' - blue = auto() + @unittest.skipIf( + python_version >= (3, 13), + 'mixed types with auto() no longer supported', + ) + def test_auto_garbage_ok(self): + with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'): + class Color(Enum): + red = 'red' + blue = auto() self.assertEqual(Color.blue.value, 1) - def test_auto_garbage_corrected(self): - class Color(Enum): - red = 'red' - blue = 2 - green = auto() + @unittest.skipIf( + python_version >= (3, 13), + 'mixed types with auto() no longer supported', + ) + def test_auto_garbage_corrected_ok(self): + with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'): + class Color(Enum): + red = 'red' + blue = 2 + green = auto() self.assertEqual(list(Color), [Color.red, Color.blue, Color.green]) self.assertEqual(Color.red.value, 'red') self.assertEqual(Color.blue.value, 2) self.assertEqual(Color.green.value, 3) + @unittest.skipIf( + python_version < (3, 13), + 'mixed types with auto() will raise in 3.13', + ) + def test_auto_garbage_fail(self): + with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'): + class Color(Enum): + red = 'red' + blue = auto() + + @unittest.skipIf( + python_version < (3, 13), + 'mixed types with auto() will raise in 3.13', + ) + def test_auto_garbage_corrected_fail(self): + with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'): + class Color(Enum): + red = 'red' + blue = 2 + green = auto() + def test_auto_order(self): with self.assertRaises(TypeError): class Color(Enum): @@ -3991,6 +4022,22 @@ class TestInternals(unittest.TestCase): self.assertEqual(Color.red.value, 'pathological case') self.assertEqual(Color.blue.value, 'blue') + @unittest.skipIf( + python_version < (3, 13), + 'auto() will return highest value + 1 in 3.13', + ) + def test_auto_with_aliases(self): + class Color(Enum): + red = auto() + blue = auto() + oxford = blue + crimson = red + green = auto() + self.assertIs(Color.crimson, Color.red) + self.assertIs(Color.oxford, Color.blue) + self.assertIsNot(Color.green, Color.red) + self.assertIsNot(Color.green, Color.blue) + def test_duplicate_auto(self): class Dupes(Enum): first = primero = auto() diff --git a/Misc/NEWS.d/next/Library/2022-04-11-16-55-41.gh-issue-91456.DK3KKl.rst b/Misc/NEWS.d/next/Library/2022-04-11-16-55-41.gh-issue-91456.DK3KKl.rst new file mode 100644 index 0000000..a4c8531 --- /dev/null +++ b/Misc/NEWS.d/next/Library/2022-04-11-16-55-41.gh-issue-91456.DK3KKl.rst @@ -0,0 +1,3 @@ +Deprecate current default auto() behavior: In 3.13 the default will be for +for auto() to always return the largest member value incremented by +1, and to raise if incompatible value types are used. |