eventsourcing 9.2.21__py3-none-any.whl → 9.3.0__py3-none-any.whl

eventsourcing/compressor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import zlib
 
 from eventsourcing.persistence import Compressor

eventsourcing/dispatch.py

@@ -1,64 +1,38 @@
 from __future__ import annotations
 
-import sys
+from functools import singledispatchmethod as _singledispatchmethod
 
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from functools import singledispatchmethod as _singledispatchmethod
 
-    class singledispatchmethod(_singledispatchmethod):
-        def register(self, cls, method=None):
-            """generic_method.register(cls, func) -> func
+class singledispatchmethod(_singledispatchmethod):  # noqa: N801
+    def __init__(self, func):
+        super().__init__(func)
+        self.deferred_registrations = []
 
-            Registers a new implementation for the given *cls* on a *generic_method*.
-            """
-            if isinstance(cls, (classmethod, staticmethod)):
-                first_annotation = {}
-                for k, v in cls.__func__.__annotations__.items():
-                    first_annotation[k] = v
-                    break
-                cls.__annotations__ = first_annotation
-            return self.dispatcher.register(cls, func=method)
-
-else:
-    from functools import singledispatch, update_wrapper
-
-    class singledispatchmethod:
-        """Single-dispatch generic method descriptor.
+    def register(self, cls, method=None):
+        """generic_method.register(cls, func) -> func
 
-        Supports wrapping existing descriptors and handles non-descriptor
-        callables as instance methods.
+        Registers a new implementation for the given *cls* on a *generic_method*.
         """
-
-        def __init__(self, func):
-            if not callable(func) and not hasattr(func, "__get__"):
-                raise TypeError(f"{func!r} is not callable or a descriptor")
-
-            self.dispatcher = singledispatch(func)
-            self.func = func
-
-        def register(self, cls, method=None):
-            """generic_method.register(cls, func) -> func
-
-            Registers a new implementation for the given *cls* on a *generic_method*.
-            """
-            if isinstance(cls, (classmethod, staticmethod)):
-                first_annotation = {}
-                for k, v in cls.__func__.__annotations__.items():
-                    first_annotation[k] = v
-                    break
-                cls.__annotations__ = first_annotation
+        if isinstance(cls, (classmethod, staticmethod)):
+            first_annotation = {}
+            for k, v in cls.__func__.__annotations__.items():
+                first_annotation[k] = v
+                break
+            cls.__annotations__ = first_annotation
+
+            # for globals in typing.get_type_hints() in Python 3.8 and 3.9
+            if not hasattr(cls, "__wrapped__"):
+                cls.__wrapped__ = cls.__func__
+
+        try:
             return self.dispatcher.register(cls, func=method)
-
-        def __get__(self, obj, cls=None):
-            def _method(*args, **kwargs):
-                method = self.dispatcher.dispatch(args[0].__class__)
-                return method.__get__(obj, cls)(*args, **kwargs)
-
-            _method.__isabstractmethod__ = self.__isabstractmethod__
-            _method.register = self.register
-            update_wrapper(_method, self.func)
-            return _method
-
-        @property
-        def __isabstractmethod__(self):
-            return getattr(self.func, "__isabstractmethod__", False)
+        except NameError:
+            self.deferred_registrations.append([cls, method])
+            # TODO: Fix this....
+            return method or cls
+
+    def __get__(self, obj, cls=None):
+        for registered_cls, registered_method in self.deferred_registrations:
+            self.dispatcher.register(registered_cls, func=registered_method)
+        self.deferred_registrations = []
+        return super().__get__(obj, cls=cls)