Add cache for repr, str and invert on Flag and IntFlag

Benchmark:
Testing with 10000 repeats, result is average of 100 tests:

    >>> str(~NewFlag.baz)  # 5.6313761773697415 ms
    'NewFlag.0'

    >>> str(~OldFlag.baz)  # 146.97604789150913 ms
    'OldFlag.0'

    >>> repr(~NewFlag.baz)  # 4.422742834372443 ms
    '<NewFlag.0: 0>'

    >>> repr(~OldFlag.baz)  # 151.49518529891247 ms
    '<OldFlag.0: 0>'

    >>> ~(~NewFlag.foo)  # 3.465736084655711 ms
    <NewFlag.foo: 1>

    >>> ~(~OldFlag.foo)  # 177.88357201820338 ms
    <OldFlag.foo: 1>

NewFlag: total: 13.5198551 ms, average: 4.4194400 ms (Fastest)
OldFlag: total: 476.3548052 ms, average: 158.2196475 ms, ~ x35.80 times slower than NewFlag

Author: Bobronium

Lib/enum.py

@@ -191,6 +191,11 @@ def __new__(metacls, cls, bases, classdict):
         # Reverse value->name map for hashable values.
         enum_class._value2member_map_ = {}
 
+        # used to speedup __str__, __repr__ and __invert__ calls when applicable
+        enum_class._repr_ = None
+        enum_class._str_ = None
+        enum_class._invert_ = None
+
         # If a custom type is mixed into the Enum, and it does not know how
         # to pickle itself, pickle.dumps will succeed but pickle.loads will
         # fail.  Rather than have the error show up later and possibly far
@@ -265,6 +270,15 @@ def __new__(metacls, cls, bases, classdict):
             except TypeError:
                 pass
 
+        # after all members created, cache result of this
+        # methods for immutable values
+        for member in enum_class._value2member_map_.copy().values():
+            for static_attr in ('__repr__', '__str__', '__invert__'):
+                method = getattr(member, static_attr, None)
+                if method is None:
+                    continue
+                setattr(member, static_attr[1:-1], method())
+
         # double check that repr and friends are not the mixin's or various
         # things break (such as pickle)
         for name in {'__repr__', '__str__', '__format__', '__reduce_ex__'}:
@@ -630,10 +644,16 @@ def _value_(self):
 
     @_value_.setter
     def _value_(self, value):
+        self._repr_ = self._str_ = None
+        if '_invert_' in self.__dict__:
+            self._invert_ = None
         object.__setattr__(self, 'value', value)
 
     @_name_.setter
     def _name_(self, name):
+        self._repr_ = self._str_ = None
+        if '_invert_' in self.__dict__:
+            self._invert_ = None
         object.__setattr__(self, 'name', name)
 
     def _generate_next_value_(name, start, count, last_values):
@@ -768,18 +788,27 @@ def __repr__(self):
         cls = self.__class__
         if self.name is not None:
             return f'<{cls.__name__}.{self.name}: {self.value!r}>'
+        cached = self._repr_
+        if cached is not None:
+            return cached
         members, uncovered = _decompose(cls, self.value)
-        return f"<{cls.__name__}.{'|'.join([str(m.name or m.value) for m in members])}: {self.value!r}>"
+        members = '|'.join([str(m.name or m.value) for m in members])
+        self._repr_ = result = f"<{cls.__name__}.{members}: {self.value!r}>"
+        return result
 
     def __str__(self):
         cls = self.__class__
         if self.name is not None:
             return f'{cls.__name__}.{self.name}'
+        cached = self._str_
+        if cached is not None:
+            return cached
         members, uncovered = _decompose(cls, self.value)
         if len(members) == 1 and members[0].name is None:
-            return f'{cls.__name__}.{members[0].value!r}'
+            self._str_ = result = f'{cls.__name__}.{members[0].value!r}'
         else:
-            return f"{cls.__name__}.{'|'.join([str(m.name or m.value) for m in members])}"
+            self._str_ = result = f"{cls.__name__}.{'|'.join([str(m.name or m.value) for m in members])}"
+        return result
 
     def __bool__(self):
         return bool(self.value)
@@ -803,13 +832,18 @@ def __xor__(self, other):
         return cls(self.value ^ other.value)
 
     def __invert__(self):
+        cached = self._invert_
+        if cached is not None:
+            return cached
         cls = self.__class__
         members, uncovered = _decompose(cls, self.value)
         inverted = cls(0)
         for m in cls:
             if m not in members and not (m.value & self.value):
                 inverted = inverted | m
-        return cls(inverted)
+        self._invert_ = result = cls(inverted)
+        result._invert_ = self
+        return result
 
 
 class IntFlag(int, Flag):
@@ -880,7 +914,10 @@ def __xor__(self, other):
     __rxor__ = __xor__
 
     def __invert__(self):
-        result = self.__class__(~self.value)
+        cached = self._invert_
+        if cached is not None:
+            return cached
+        self._invert_ = result = self.__class__(~self.value)
         return result
 
 

Lib/test/test_enum.py

@@ -16,6 +16,8 @@
 
 
 # for pickle tests
+from unittest import mock
+
 try:
     class Stooges(Enum):
         LARRY = 1
@@ -3112,5 +3114,55 @@ def test_get_raise(self):
                 getattr(self.SquareFoo.b, attr)
 
 
+class TestStaticAttrs(unittest.TestCase):
+
+    def test_invert_cache(self):
+        class Foo(Flag):
+            a = 1
+            b = 2
+            c = 3
+
+        with mock.patch('enum._decompose') as decompose_mock:
+            self.assertIs(Foo.a._invert_, Foo.b)
+            self.assertIs(Foo.b._invert_, Foo.a)
+            self.assertIsNotNone(Foo.c._invert_)
+            self.assertIs(~(~Foo.a), Foo.a)
+        self.assertFalse(decompose_mock.called)
+
+    def test_repr_str_cache(self):
+        class Foo(Flag):
+            a = 1
+            b = 2
+            c = 3
+
+        with mock.patch('enum._decompose') as decompose_mock:
+            no_name = ~Foo.c
+        self.assertFalse(decompose_mock.called)
+        no_name_repr = repr(no_name)
+        no_name_str = str(no_name)
+        self.assertEqual(no_name_repr, '<Foo.0: 0>')
+        self.assertEqual(no_name_str, 'Foo.0')
+
+        with mock.patch('enum._decompose') as decompose_mock:
+            self.assertIs(repr(no_name), no_name_repr)
+            self.assertIs(str(no_name), no_name_str)
+        self.assertFalse(decompose_mock.called)
+
+    def test_cache_invalidate(self):
+        class Foo(Flag):
+            a = 1
+            b = 2
+            c = 3
+
+        self.assertIs(Foo.a._invert_, Foo.b)
+        Foo.a._value_ = 3
+        self.assertIsNone(Foo.a._invert_)
+        self.assertIsNone(Foo.a._str_)
+        self.assertIsNone(Foo.a._repr_)
+        self.assertIs(~Foo.a, ~Foo.c)
+        self.assertEqual(repr(Foo.a), '<Foo.a: 3>')
+        self.assertEqual(str(Foo.a), 'Foo.a')
+
+
 if __name__ == '__main__':
     unittest.main()