Ensure total compatibility of C/Python implementations of uuid4 / uuid7

A side effect of some compatility fixes is the new code, with which
the new C uuid7() is now 35x faster that pure Python (used to be 30x).

Author: 1st1

Lib/test/test_uuid.py

@@ -1524,6 +1524,24 @@ def test_windll_getnode(self):
         self.check_node(node)
 
 
+class UuidHooks:
+
+    def __init__(self, *, start_at=0, inc_by=0, seed=0):
+        self._time = start_at
+        self._inc_by = inc_by
+        self._rnd = random.Random(seed)
+
+    def random_func (self, size) :
+        ret = b''
+        for _ in range(size) :
+            ret += self._rnd.getrandbits(8).to_bytes(1, 'big')
+        return ret
+
+    def time_func(self):
+        self._time += self._inc_by
+        return self._time
+
+
 @unittest.skipUnless(c_uuid, "requires the C _uuid module")
 class TestCImplementationCompat(unittest.TestCase):
     def test_compatibility(self):
@@ -1595,6 +1613,55 @@ def full_test(p, u):
         self.assertEqual(len(all_ps), len(all_us))
         self.assertEqual(len(all_ps), len(uuids))
 
+    def _install_hooks(self, uuid_mod, *, start_at=0, inc_by=0, seed=0):
+        py_hooks = UuidHooks(start_at=start_at, inc_by=inc_by, seed=seed)
+        uuid_mod._install_py_hooks(
+            random_func=py_hooks.random_func,
+            time_func=py_hooks.time_func
+        )
+
+        c_hooks = UuidHooks(start_at=start_at, inc_by=inc_by, seed=seed)
+        uuid_mod._install_c_hooks(
+            random_func=c_hooks.random_func,
+            time_func=c_hooks.time_func
+        )
+
+    def _reset_hooks(self, uuid_mod):
+        uuid_mod._install_c_hooks(random_func=None, time_func=None)
+        uuid_mod._install_py_hooks(random_func=None, time_func=None)
+
+    def test_exact_same_algo_uuid4(self):
+        import uuid
+
+        self._install_hooks(uuid)
+        try:
+            for seq_number in range(100):
+                with self.subTest(seq_number=seq_number):
+                    self.assertEqual(
+                        uuid._py_uuid4().hex,
+                        uuid._c_uuid4().hex,
+                    )
+        finally:
+            self._reset_hooks(uuid)
+
+    def test_exact_same_algo_uuid7(self):
+        import uuid
+
+        try:
+            for start_at, inc_by in [
+                (0, 0), (0, 10_000_000), (10_000_000 + 142, 1131827398127397)
+            ]:
+                self._install_hooks(uuid, start_at=start_at, inc_by=inc_by)
+                for seq_number in range(100):
+                    with self.subTest(
+                        seq_number=seq_number, start_at=start_at, inc_by=inc_by,
+                    ):
+                        self.assertEqual(
+                            uuid._py_uuid7().hex,
+                            uuid._c_uuid7().hex,
+                        )
+        finally:
+            self._reset_hooks(uuid)
 
 
 if __name__ == '__main__':

Lib/uuid.py

@@ -111,6 +111,33 @@ class SafeUUID:
 _RFC_4122_VERSION_7_FLAGS = ((7 << 76) | (0x8000 << 48))
 _RFC_4122_VERSION_8_FLAGS = ((8 << 76) | (0x8000 << 48))
 
+_random_hook = None
+_time_hook = None
+
+
+def _gen_random(size):
+    if _random_hook is None:
+        return os.urandom(size)
+    else:
+        return _random_hook(size)
+
+
+def _gen_time():
+    if _time_hook is None:
+        return time.time_ns()
+    else:
+        return _time_hook()
+
+
+def _install_py_hooks(*, random_func, time_func):
+    global _random_hook
+    global _time_hook
+    global _last_timestamp_v7
+    _random_hook = random_func
+    _time_hook = time_func
+    # Reset _last_timestamp_v7 for repeatability of tests
+    _last_timestamp_v7 = None
+
 
 # Import optional C extension at toplevel, to help disabling it when testing
 try:
@@ -783,7 +810,7 @@ def uuid3(namespace, name):
 
 def uuid4():
     """Generate a random UUID."""
-    int_uuid_4 = int.from_bytes(os.urandom(16))
+    int_uuid_4 = int.from_bytes(_gen_random(16))
     int_uuid_4 &= _RFC_4122_CLEARFLAGS_MASK
     int_uuid_4 |= _RFC_4122_VERSION_4_FLAGS
     return UUID._from_int(int_uuid_4)
@@ -843,7 +870,8 @@ def uuid6(node=None, clock_seq=None):
 _last_counter_v7 = 0  # 42-bit counter
 
 def _uuid7_get_counter_and_tail():
-    rand = int.from_bytes(os.urandom(10))
+    rand = int.from_bytes(_gen_random(10), 'big')
+
     # 42-bit counter with MSB set to 0
     counter = (rand >> 32) & 0x1ff_ffff_ffff
     # 32-bit random data
@@ -872,7 +900,7 @@ def uuid7():
     global _last_timestamp_v7
     global _last_counter_v7
 
-    nanoseconds = time.time_ns()
+    nanoseconds = _gen_time()
     timestamp_ms = nanoseconds // 1_000_000
 
     if _last_timestamp_v7 is None or timestamp_ms > _last_timestamp_v7:
@@ -888,7 +916,7 @@ def uuid7():
             counter, tail = _uuid7_get_counter_and_tail()
         else:
             # 32-bit random data
-            tail = int.from_bytes(os.urandom(4))
+            tail = int.from_bytes(_gen_random(4))
 
     unix_ts_ms = timestamp_ms & 0xffff_ffff_ffff
     counter_msbs = counter >> 30
@@ -946,6 +974,7 @@ def uuid8(a=None, b=None, c=None):
 _py_UUID = UUID
 try:
     from _uuid import UUID, uuid4, uuid7
+    from _uuid import _install_c_hooks
 except ImportError:
     _c_UUID = None
     _c_uuid4 = None