Apply changes from python/cpython#17669

Run builtin python tests directly from python test module
Refactor patch applying

Author: Bobronium

README.md

@@ -1,31 +1,37 @@
 # fastenum
 #### Patch for builtin `enum` module to achieve best performance
 
-### TL;DR
-- up to 6x faster members access
-- up to 10x faster members `name`/`value` access
-- up to 2x faster values positive check
-- up to 3x faster values negative check
-- up to 3x faster iteration
+This patch is based on
+[python/cpython#17669](https://github.com/python/cpython/pull/17669) and [python/cpython#16483](https://github.com/python/cpython/pull/16483) 
 
+### Why?
+- ~100x faster new `Flags` and `IntFlags` creation
+- ~10x faster `name`/`value` access
+- ~6x faster access to enum members
+- ~2x faster values positive check
+- ~3x faster values negative check
+- ~3x faster iteration
 
 
-#### To enable patch, just import fastenum once:
-###### **Make sure you import it before importing anything else, otherwise things could (will) break**
+### Wow it's fast! How I do use it?
+To enable patch, just import fastenum once:
 ```python
 import fastenum
-assert fastenum.enabled
 
-from enum import Enum
-assert Enum.__is_fast__()
+assert fastenum.enabled
 ```
+After you imported fastenum package, all your Enums are patched and fast!
+
+You don't need to re-apply patch across different modules: once it's patched it'll work everywhere.
 
-#### What's changed?
-- `EnumMeta.__getattr__` is removed
-- `DynamicClassAttribute` is removed in favor of instance attributes
-- `name`/`value` are ordinal attributes and put in `__slots__` when possible
-- `_missing_` type check is removed, as it was re-e-e-ally slowing things down  _(kinda breaking change, but who cares?)_
-- `_order_` was removed as since python 3.6 dicts preserve order
-- some other minor improvements
 
-I feel that this actually needs to be in stdlib, but patching all this stuff was actually easier for me that opening issue in python bug tracker
+### What's changed?
+All changes are backwards compatible, so you should be ok with any of your existing code. 
+But of course, always test first!
+- Optimized `Enum.__new__`
+- Remove `EnumMeta.__getattr__`
+- Store `Enum.name` and `.value` in members `__dict__` for faster access
+- Replace `Enum._member_names_` with `._unique_member_map_` for faster lookups and iteration (old arg still remains)
+- Replace `_EmumMeta._member_names` and `._last_values` with `.members` mapping (old args still remain)
+- Add support for direct setting and getting class attrs on `DynamicClassAttribute` without need to use slow `__getattr__`
+- Various minor improvements

fastenum/__init__.py

@@ -1,7 +1,7 @@
-from enum import Enum
+import enum
 
 from .parcher import _get_all_subclasses, Patch, PatchMeta
-from .patches import EnumMetaPatch, EnumPatch
+from .patches import EnumMetaPatch, EnumPatch, DynamicClassAttributePatch, EnumDictPatch
 
 __all__ = (
     'disable',
@@ -11,46 +11,36 @@
 
 enabled = False
 
+orig_decompose = enum._decompose
+
 
 def enable():
     """
     Patches enum for best performance
     """
     global enabled
     if enabled:
-        raise RuntimeError('Builtin enum is already patched')
+        raise RuntimeError('Nothing to enable: patch is already applied')
 
     patch: PatchMeta
     for patch in Patch.__subclasses__():
         patch.enable()
-
-    # setting missing attributes to enum types and members that were created before patch
-    for enum_cls in _get_all_subclasses(Enum):
-        unique_members = set(enum_cls._member_names_)
-        type.__setattr__(
-            enum_cls,
-            '_unique_members_',
-            {k: v for k, v in enum_cls._member_map_.items() if k in unique_members}
-        )
-        # e._value2member_map_ can have extra members so prefer it,
-        # but it also can be empty if values are unhashable
-        for member in (enum_cls._value2member_map_ or enum_cls._member_map_).values():
-            object.__setattr__(member, 'name', member._name_)
-            object.__setattr__(member, 'value', member._value_)
+    enum._decompose = patches._decompose
     enabled = True
 
 
 def disable():
     """
-    Opposite of enable()
+    Restores enum to its origin state
     """
     global enabled
     if not enabled:
-        raise RuntimeError('Builtin enum was not patched yet')
+        raise RuntimeError('Nothing to disable: patch was not applied')
 
     patch: PatchMeta
     for patch in Patch.__subclasses__():
         patch.disable()
+    enum._decompose = orig_decompose
     enabled = False
 
 

fastenum/parcher.py

@@ -1,4 +1,5 @@
-from typing import MutableMapping, Any, Set, Type
+import gc
+from typing import MutableMapping, Any, Set, Type, Callable
 
 
 class _Missing:
@@ -47,16 +48,20 @@ def set_attr(t, name, value):
 class PatchMeta(type):
     __enabled__: bool
 
+    __run_on_class__: Callable[[Type[Any]], None]
+    __run_on_instance__: Callable[[Any], None]
+
     def __prepare__(cls, *args, **kwargs):
         return type.__prepare__(*args, **kwargs)
 
-    def __new__(mcs, name, bases, namespace, target=None, delete=None, update=None):
+    def __new__(mcs, name, bases, namespace, target=None, delete=None, update=None, keep=None):
         target = target or namespace.pop('__target__', None)
         if target is None:
-            return type.__new__(mcs, name, bases, {})
+            return type.__new__(mcs, name, bases, namespace)
 
         to_delete = delete or namespace.pop('__to_delete__', set())
         to_update = update or namespace.pop('__to_update__', set())
+        to_keep = keep or namespace.pop('__to_keep__', set())
 
         patched_attrs = {
             attr: namespace[attr]
@@ -68,12 +73,12 @@ def __new__(mcs, name, bases, namespace, target=None, delete=None, update=None):
             for attr in to_update | to_delete
             if attr in target.__dict__
         }
-        cls = type.__new__(mcs, name, bases, {})
+        cls = type.__new__(mcs, name, bases, namespace)
 
         cls.__target__ = target
         cls.__to_update__ = patched_attrs
         cls.__original_attrs__ = original_attrs
-        cls.__extra__ = (to_update | to_delete) ^ original_attrs.keys()
+        cls.__extra__ = (to_update | to_delete) ^ (original_attrs.keys() | to_keep)
         cls.__to_delete__ = to_delete
         cls.__redefined_on_subclasses__ = {}
         cls.__enabled__ = False
@@ -83,6 +88,16 @@ def enable(cls):
         target = cls.__target__
         subclasses = _get_all_subclasses(target)
 
+        if cls.__run_on_class__:
+            cls.__run_on_class__(target)
+            for sub_cls in subclasses:
+                cls.__run_on_class__(sub_cls)
+
+        if cls.__run_on_instance__:
+            for obj in gc.get_objects():
+                if isinstance(obj, target):
+                    cls.__run_on_instance__(obj)
+
         for attr in cls.__to_delete__:
             old_value = del_attr(target, attr)
             if old_value is MISSING:
@@ -118,7 +133,12 @@ def disable(cls):
 
 
 class Patch(metaclass=PatchMeta):
+    """Class to declare attributes to patch other classes"""
+
     __target__: Type[Any]
     __to_update__: Set[str]
     __to_delete__: Set[str]
     __enabled__: bool
+
+    __run_on_class__: Callable[[Type[Any]], None] = None
+    __run_on_instance__: Callable[[Any], None] = None