gh-139122: Add node hooks for UUIDv6 tests

Author: 1st1

Include/internal/pycore_global_objects_fini_generated.h

@@ -690,6 +690,7 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(nlocals)
         STRUCT_FOR_ID(node)
         STRUCT_FOR_ID(node_depth)
+        STRUCT_FOR_ID(node_func)
         STRUCT_FOR_ID(node_offset)
         STRUCT_FOR_ID(nothing)
         STRUCT_FOR_ID(ns)

Include/internal/pycore_global_strings.h

@@ -898,20 +898,19 @@ def test_uuid5(self):
             equal(str(u), v)
 
     @contextlib.contextmanager
-    def _uuid6_hooks(self, nanoseconds, *, random_func=None):
+    def _uuid6_hooks(self, nanoseconds, *, random_func=None, node_func=None):
         time_func = nanoseconds if callable(nanoseconds) else lambda: nanoseconds
-        with support.swap_item(sys.modules, 'uuid', self.uuid):
-            self.uuid._install_py_hooks(random_func=random_func,
-                                        time_func=time_func)
+        self.uuid._install_py_hooks(random_func=random_func,
+                                    time_func=time_func, node_func=node_func)
+        if self.is_c_uuid:
+            self.uuid._install_c_hooks(random_func=random_func,
+                                       time_func=time_func, node_func=node_func)
+        try:
+            yield
+        finally:
+            self.uuid._install_py_hooks(random_func=None, time_func=None)
             if self.is_c_uuid:
-                self.uuid._install_c_hooks(random_func=random_func,
-                                           time_func=time_func)
-            try:
-                yield
-            finally:
-                self.uuid._install_py_hooks(random_func=None, time_func=None)
-                if self.is_c_uuid:
-                    self.uuid._install_c_hooks(random_func=None, time_func=None)
+                self.uuid._install_c_hooks(random_func=None, time_func=None)
 
     def test_uuid6(self):
         equal = self.assertEqual
@@ -928,10 +927,8 @@ def random_func(size):
             data = (fake_clock_seq | 0xc000).to_bytes(2, 'big')
             return (data * ((size + 1) // 2))[:size]
 
-        with (
-            self._uuid6_hooks(fake_nanoseconds, random_func=random_func),
-            mock.patch.object(self.uuid, 'getnode', return_value=fake_node_value),
-        ):
+        with self._uuid6_hooks(fake_nanoseconds, random_func=random_func,
+                              node_func=lambda: fake_node_value):
             u = self.uuid.uuid6()
             equal(u.variant, self.uuid.RFC_4122)
             equal(u.version, 6)
@@ -1069,11 +1066,13 @@ def random_func(size):
             with self.assertRaises(RuntimeError) as cm:
                 self.uuid.uuid6(node=0)
             self.assertIs(cm.exception, error)
-        with self._uuid6_hooks(0):
-            with mock.patch.object(self.uuid, 'getnode', side_effect=error):
-                with self.assertRaises(RuntimeError) as cm:
-                    self.uuid.uuid6(clock_seq=0)
-                self.assertIs(cm.exception, error)
+        def node_func():
+            raise error
+
+        with self._uuid6_hooks(0, node_func=node_func):
+            with self.assertRaises(RuntimeError) as cm:
+                self.uuid.uuid6(clock_seq=0)
+            self.assertIs(cm.exception, error)
 
     def test_uuid6_monotonicity(self):
         # Repeated and backward clock readings must still advance the timestamp.
@@ -1918,17 +1917,20 @@ 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):
+    def _install_hooks(self, uuid_mod, *, start_at=0, inc_by=0, seed=0,
+                       node_func=None):
         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
+            time_func=py_hooks.time_func,
+            node_func=node_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
+            time_func=c_hooks.time_func,
+            node_func=node_func,
         )
 
     def _reset_hooks(self, uuid_mod):
@@ -1943,19 +1945,19 @@ def test_exact_same_algo_uuid6(self):
 
         values = (None, 0, -1, (1 << 100) | 0x123456789abc)
         try:
-            with mock.patch.object(uuid, 'getnode', return_value=0x123456789abc):
-                for start_at in (-1001, 0, 1672533296123456789):
-                    for inc_by in (-101, 0, 101, 1000000):
-                        for node, clock_seq in product(values, repeat=2):
-                            self._install_hooks(uuid, start_at=start_at,
-                                                inc_by=inc_by)
-                            with self.subTest(start=start_at, inc=inc_by,
-                                              node=node, clock_seq=clock_seq):
-                                for _ in range(200):
-                                    self.assertEqual(
-                                        uuid._py_uuid6(node, clock_seq).bytes,
-                                        uuid._c_uuid6(node, clock_seq).bytes,
-                                    )
+            for start_at in (-1001, 0, 1672533296123456789):
+                for inc_by in (-101, 0, 101, 1000000):
+                    for node, clock_seq in product(values, repeat=2):
+                        self._install_hooks(uuid, start_at=start_at,
+                                            inc_by=inc_by,
+                                            node_func=lambda: 0x123456789abc)
+                        with self.subTest(start=start_at, inc=inc_by,
+                                          node=node, clock_seq=clock_seq):
+                            for _ in range(200):
+                                self.assertEqual(
+                                    uuid._py_uuid6(node, clock_seq).bytes,
+                                    uuid._c_uuid6(node, clock_seq).bytes,
+                                )
         finally:
             self._reset_hooks(uuid)
 
@@ -1988,36 +1990,37 @@ def test_uuid6_node_cache(self):
         self.addCleanup(uuid._install_c_hooks, random_func=None, time_func=None)
         for node in (0, -1):
             with self.subTest(node=node):
-                uuid._install_c_hooks(random_func=None, time_func=None)
-                with mock.patch.object(uuid, 'getnode', return_value=node) as getnode:
-                    self.assertEqual(uuid.uuid6(clock_seq=0).node,
-                                     node & 0xffffffffffff)
-                    self.assertEqual(uuid.uuid6(node=42, clock_seq=0).node, 42)
-                    self.assertEqual(uuid.uuid6(clock_seq=0).node,
-                                     node & 0xffffffffffff)
-                    getnode.assert_called_once_with()
+                getnode = mock.Mock(return_value=node)
+                uuid._install_c_hooks(random_func=None, time_func=None,
+                                      node_func=getnode)
+                self.assertEqual(uuid.uuid6(clock_seq=0).node,
+                                 node & 0xffffffffffff)
+                self.assertEqual(uuid.uuid6(node=42, clock_seq=0).node, 42)
+                self.assertEqual(uuid.uuid6(clock_seq=0).node,
+                                 node & 0xffffffffffff)
+                getnode.assert_called_once_with()
 
     def test_uuid6_node_cache_error(self):
         # A failed lookup must leave the cache empty so the next call can retry.
         import uuid
 
-        uuid._install_c_hooks(random_func=None, time_func=None)
         self.addCleanup(uuid._install_c_hooks, random_func=None, time_func=None)
         error = RuntimeError('node lookup failed')
-        with mock.patch.object(uuid, 'getnode', side_effect=[error, 42]) as getnode:
-            with self.assertRaises(RuntimeError) as cm:
-                uuid.uuid6(clock_seq=0)
-            self.assertIs(cm.exception, error)
-            self.assertEqual(uuid.uuid6(clock_seq=0).node, 42)
-            self.assertEqual(uuid.uuid6(clock_seq=0).node, 42)
-            self.assertEqual(getnode.call_count, 2)
+        getnode = mock.Mock(side_effect=[error, 42])
+        uuid._install_c_hooks(random_func=None, time_func=None,
+                              node_func=getnode)
+        with self.assertRaises(RuntimeError) as cm:
+            uuid.uuid6(clock_seq=0)
+        self.assertIs(cm.exception, error)
+        self.assertEqual(uuid.uuid6(clock_seq=0).node, 42)
+        self.assertEqual(uuid.uuid6(clock_seq=0).node, 42)
+        self.assertEqual(getnode.call_count, 2)
 
     def test_uuid6_node_cache_reentrant(self):
         # getnode() can reenter uuid6(). The recursive call initializes the cache;
         # the outer call must reuse that value without deadlocking or replacing it.
         import uuid
 
-        uuid._install_c_hooks(random_func=None, time_func=None)
         self.addCleanup(uuid._install_c_hooks, random_func=None, time_func=None)
         recursive = False
 
@@ -2029,8 +2032,9 @@ def getnode():
                 return 22
             return 11
 
-        with mock.patch.object(uuid, 'getnode', side_effect=getnode):
-            self.assertEqual(uuid.uuid6(clock_seq=0).node, 11)
+        uuid._install_c_hooks(random_func=None, time_func=None,
+                              node_func=getnode)
+        self.assertEqual(uuid.uuid6(clock_seq=0).node, 11)
 
     @threading_helper.requires_working_threading()
     @threading_helper.reap_threads
@@ -2057,17 +2061,17 @@ def generate():
             local.id = 1
             return uuid.uuid6(clock_seq=0)
 
-        uuid._install_c_hooks(random_func=None, time_func=None)
+        uuid._install_c_hooks(random_func=None, time_func=None,
+                              node_func=getnode)
         self.addCleanup(uuid._install_c_hooks, random_func=None, time_func=None)
-        with mock.patch.object(uuid, 'getnode', side_effect=getnode):
-            with ThreadPoolExecutor(1) as pool:
-                pending = pool.submit(generate)
-                try:
-                    self.assertTrue(entered.wait(support.SHORT_TIMEOUT))
-                    other = uuid.uuid6(clock_seq=0)
-                finally:
-                    resume.set()
-                first = pending.result(timeout=support.SHORT_TIMEOUT)
+        with ThreadPoolExecutor(1) as pool:
+            pending = pool.submit(generate)
+            try:
+                self.assertTrue(entered.wait(support.SHORT_TIMEOUT))
+                other = uuid.uuid6(clock_seq=0)
+            finally:
+                resume.set()
+            first = pending.result(timeout=support.SHORT_TIMEOUT)
         self.assertEqual(first.node, 2)
         self.assertEqual(other.node, 2)
 

Include/internal/pycore_runtime_init_generated.h

@@ -113,6 +113,7 @@ class SafeUUID:
 
 _random_hook = None
 _time_hook = None
+_node_hook = None
 
 
 def _gen_random(size):
@@ -129,13 +130,21 @@ def _gen_time():
         return _time_hook()
 
 
-def _install_py_hooks(*, random_func, time_func):
+def _gen_node():
+    if _node_hook is None:
+        return getnode()
+    return _node_hook()
+
+
+def _install_py_hooks(*, random_func, time_func, node_func=None):
     global _random_hook
     global _time_hook
+    global _node_hook
     global _last_timestamp_v7
     global _last_timestamp_v6
     _random_hook = random_func
     _time_hook = time_func
+    _node_hook = node_func
     # Reset timestamps for repeatability of tests.
     _last_timestamp_v7 = None
     _last_timestamp_v6 = None
@@ -848,7 +857,7 @@ def uuid6(node=None, clock_seq=None):
     time_lo = timestamp & 0x0fff  # keep 12 bits and clear version bits
     clock_s = clock_seq & 0x3fff  # keep 14 bits and clear variant bits
     if node is None:
-        node = getnode()
+        node = _gen_node()
     # --- 32 + 16 ---   -- 4 --   -- 12 --  -- 2 --   -- 14 ---    48
     # time_hi_and_mid | version | time_lo | variant | clock_seq | node
     int_uuid_6 = time_hi_and_mid << 80

Include/internal/pycore_unicodeobject_generated.h

@@ -180,6 +180,7 @@ typedef struct {
     PyObject *random_func;
     PyObject *random_size_int;
     PyObject *time_func;
+    PyObject *node_func;
 
     // A freelist for uuid objects -- 15-20% performance boost.
     uuidobject *freelist;
@@ -423,7 +424,8 @@ uuid6_get_node(uuid_state *state, uint64_t *result)
         Py_BEGIN_CRITICAL_SECTION_MUTEX(&state->node_mutex);
         node_id = _Py_atomic_load_uint64_relaxed(&state->node_id);
         if (node_id == NODE_NOT_INITIALIZED) {
-            PyObject *getnode = get_uuidmod_attr("getnode");
+            PyObject *getnode = state->node_func != NULL
+                ? Py_NewRef(state->node_func) : get_uuidmod_attr("getnode");
             PyObject *value = NULL;
             if (getnode != NULL) {
                 value = PyObject_CallNoArgs(getnode);
@@ -655,13 +657,14 @@ _uuid._install_c_hooks
     *
     random_func: object
     time_func: object
+    node_func: object = None
 
 [clinic start generated code]*/
 
 static PyObject *
 _uuid__install_c_hooks_impl(PyObject *module, PyObject *random_func,
-                            PyObject *time_func)
-/*[clinic end generated code: output=884aa6e91b2ea832 input=6c5017297067e2ea]*/
+                            PyObject *time_func, PyObject *node_func)
+/*[clinic end generated code: output=e742978b99d5a2ea input=beb6f73390b31d93]*/
 {
     uuid_state *state = get_uuid_state(module);
 
@@ -671,6 +674,8 @@ _uuid__install_c_hooks_impl(PyObject *module, PyObject *random_func,
     state->last_timestamp_v6_init = 0;
     state->last_timestamp_v7_init = 0;
     Py_BEGIN_CRITICAL_SECTION_MUTEX(&state->node_mutex);
+    Py_XSETREF(state->node_func,
+               node_func == Py_None ? NULL : Py_NewRef(node_func));
     _Py_atomic_store_uint64_relaxed(&state->node_id, NODE_NOT_INITIALIZED);
     Py_END_CRITICAL_SECTION();
 
@@ -1923,6 +1928,7 @@ module_traverse(PyObject *mod, visitproc visit, void *arg)
     Py_VISIT(state->uint128_max);
     Py_VISIT(state->random_func);
     Py_VISIT(state->time_func);
+    Py_VISIT(state->node_func);
     Py_VISIT(state->random_size_int);
     return 0;
 }
@@ -1937,6 +1943,7 @@ module_clear(PyObject *mod)
     Py_CLEAR(state->uint128_max);
     Py_CLEAR(state->random_func);
     Py_CLEAR(state->time_func);
+    Py_CLEAR(state->node_func);
     Py_CLEAR(state->random_size_int);
 
     if (state->freelist != NULL) {
@@ -2019,6 +2026,7 @@ uuid_exec(PyObject *module)
     state->random_last_pid = uuid_getpid();
 
     state->time_func = NULL;
+    state->node_func = NULL;
     state->random_func = NULL;
     state->random_size_int = PyLong_FromSize_t((Py_ssize_t)RANDOM_BUF_SIZE);
     if (state->random_size_int == NULL) {