Make our UUID implementation compatible with 3.8

Author: 1st1

codecs/uuid.pyx

@@ -11,7 +11,7 @@ cdef uuid_encode(CodecContext settings, WriteBuffer wbuf, obj):
 
     if type(obj) is pg_UUID:
         wbuf.write_int32(<int32_t>16)
-        wbuf.write_cstr((<PgBaseUUID>obj)._data, 16)
+        wbuf.write_cstr((<UUID>obj)._data, 16)
     elif cpython.PyUnicode_Check(obj):
         pg_uuid_bytes_from_str(obj, buf)
         wbuf.write_int32(<int32_t>16)

uuid.pyx

@@ -2,7 +2,7 @@ import functools
 import uuid
 
 from libc.stdint cimport uint64_t, uint8_t, int8_t
-from libc.string cimport memcpy
+from libc.string cimport memcpy, strncmp
 
 
 # A more efficient UUID type implementation
@@ -40,14 +40,6 @@ cdef inline char i64_to_hex(uint64_t num, char *s):
     return 0
 
 
-cdef pg_uuid_from_buf(const char *buf):
-    cdef:
-        PgBaseUUID u = UUID.__new__(UUID)
-    memcpy(u._data, buf, 16)
-    u._int = None
-    return u
-
-
 cdef pg_uuid_bytes_from_str(str u, char *out):
     cdef:
         char *orig_buf
@@ -95,11 +87,27 @@ cdef pg_uuid_bytes_from_str(str u, char *out):
                 f'invalid UUID {u!r}: decodes to less than 16 bytes')
 
 
-cdef class PgBaseUUID:
+cdef class __UUIDReplaceMe:
+    pass
+
+
+cdef pg_uuid_from_buf(const char *buf):
+    cdef:
+        UUID u = UUID.__new__(UUID)
+    memcpy(u._data, buf, 16)
+    return u
+
+
+@cython.final
+@cython.no_gc_clear
+@cython.freelist(128)
+cdef class UUID(__UUIDReplaceMe):
 
     cdef:
         char _data[16]
         object _int
+        object _hash
+        object __weakref__
 
     def __init__(self, inp):
         cdef:
@@ -117,19 +125,21 @@ cdef class PgBaseUUID:
         else:
             raise TypeError(f'a bytes or str object expected, got {inp!r}')
 
-        self._int = None
+    @property
+    def bytes(self):
+        return cpython.PyBytes_FromStringAndSize(self._data, 16)
 
-    property bytes:
-        def __get__(self):
-            return cpython.PyBytes_FromStringAndSize(self._data, 16)
+    @property
+    def int(self):
+        if self._int is None:
+            # The cache is important because `self.int` can be
+            # used multiple times by __hash__ etc.
+            self._int = int.from_bytes(self.bytes, 'big')
+        return self._int
 
-    property int:
-        def __get__(self):
-            if self._int is None:
-                # The cache is important because `self.int` can be
-                # used multiple times by __hash__ etc.
-                self._int = int.from_bytes(self.bytes, 'big')
-            return self._int
+    @property
+    def is_safe(self):
+        return uuid.SafeUUID.unknown
 
     def __str__(self):
         cdef:
@@ -158,9 +168,172 @@ cdef class PgBaseUUID:
     def __reduce__(self):
         return (type(self), (self.bytes,))
 
+    def __eq__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) == 0
+        if isinstance(other, uuid.UUID):
+            return self.int == other.int
+        return NotImplemented
+
+    def __ne__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) != 0
+        if isinstance(other, uuid.UUID):
+            return self.int != other.int
+        return NotImplemented
+
+    def __lt__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) < 0
+        if isinstance(other, uuid.UUID):
+            return self.int < other.int
+        return NotImplemented
+
+    def __gt__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) > 0
+        if isinstance(other, uuid.UUID):
+            return self.int > other.int
+        return NotImplemented
+
+    def __le__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) <= 0
+        if isinstance(other, uuid.UUID):
+            return self.int <= other.int
+        return NotImplemented
+
+    def __ge__(self, other):
+        if type(other) is UUID:
+            return strncmp(self._data, (<UUID>other)._data, 16) >= 0
+        if isinstance(other, uuid.UUID):
+            return self.int >= other.int
+        return NotImplemented
+
+    def __hash__(self):
+        # In EdgeDB every schema object has a uuid and there are
+        # huge hash-maps of them. We want UUID.__hash__ to be
+        # as fast as possible.
+        if self._hash is not None:
+            return self._hash
+
+        self._hash = hash(self.int)
+        return self._hash
+
+    def __int__(self):
+        return self.int
+
+    @property
+    def bytes_le(self):
+        bytes = self.bytes
+        return (bytes[4-1::-1] + bytes[6-1:4-1:-1] + bytes[8-1:6-1:-1] +
+                bytes[8:])
+
+    @property
+    def fields(self):
+        return (self.time_low, self.time_mid, self.time_hi_version,
+                self.clock_seq_hi_variant, self.clock_seq_low, self.node)
+
+    @property
+    def time_low(self):
+        return self.int >> 96
+
+    @property
+    def time_mid(self):
+        return (self.int >> 80) & 0xffff
+
+    @property
+    def time_hi_version(self):
+        return (self.int >> 64) & 0xffff
+
+    @property
+    def clock_seq_hi_variant(self):
+        return (self.int >> 56) & 0xff
+
+    @property
+    def clock_seq_low(self):
+        return (self.int >> 48) & 0xff
+
+    @property
+    def time(self):
+        return (((self.time_hi_version & 0x0fff) << 48) |
+                (self.time_mid << 32) | self.time_low)
+
+    @property
+    def clock_seq(self):
+        return (((self.clock_seq_hi_variant & 0x3f) << 8) |
+                self.clock_seq_low)
+
+    @property
+    def node(self):
+        return self.int & 0xffffffffffff
+
+    @property
+    def hex(self):
+        cdef:
+            uint64_t u
+            char out[32]
 
-class UUID(PgBaseUUID, uuid.UUID):
-    __slots__ = ()
+        u = <uint64_t>hton.unpack_int64(self._data)
+        i64_to_hex(u, out)
+        u = <uint64_t>hton.unpack_int64(self._data + 8)
+        i64_to_hex(u, out + 16)
+
+        return cpythonx.PyUnicode_FromKindAndData(
+            cpythonx.PyUnicode_1BYTE_KIND, <void*>out, 32)
+
+    @property
+    def urn(self):
+        return 'urn:uuid:' + str(self)
+
+    @property
+    def variant(self):
+        if not self.int & (0x8000 << 48):
+            return uuid.RESERVED_NCS
+        elif not self.int & (0x4000 << 48):
+            return uuid.RFC_4122
+        elif not self.int & (0x2000 << 48):
+            return uuid.RESERVED_MICROSOFT
+        else:
+            return uuid.RESERVED_FUTURE
+
+    @property
+    def version(self):
+        # The version bits are only meaningful for RFC 4122 UUIDs.
+        if self.variant == uuid.RFC_4122:
+            return int((self.int >> 76) & 0xf)
+
+
+# <hack>
+# In order for `isinstance(pgproto.UUID, uuid.UUID)` to work,
+# patch __bases__ and __mro__ by injecting `uuid.UUID`.
+#
+# We apply brute-force here because the following pattern stopped
+# working with Python 3.8:
+#
+#   cdef class OurUUID:
+#       ...
+#
+#   class UUID(OurUUID, uuid.UUID):
+#       ...
+#
+# With Python 3.8 it now produces
+#
+#   "TypeError: multiple bases have instance lay-out conflict"
+#
+# error.  Maybe it's possible to fix this some other way, but
+# the best solution possible would be to just contribute our
+# faster UUID to the standard library and not have this problem
+# at all.  For now this hack is pretty safe and should be
+# compatible with future Pythons for long enough.
+#
+assert UUID.__bases__[0] is __UUIDReplaceMe
+assert UUID.__mro__[1] is __UUIDReplaceMe
+cpython.Py_INCREF(uuid.UUID)
+cpython.PyTuple_SET_ITEM(UUID.__bases__, 0, uuid.UUID)
+cpython.Py_INCREF(uuid.UUID)
+cpython.PyTuple_SET_ITEM(UUID.__mro__, 1, uuid.UUID)
+# </hack>
 
 
 cdef pg_UUID = UUID