Add some more tests.

Author: ZeroIntensity

Lib/concurrent/interpreters/__init__.py

@@ -7,7 +7,7 @@
 # aliases:
 from _interpreters import (
     InterpreterError, InterpreterNotFoundError, NotShareableError,
-    is_shareable, SharedObjectProxy
+    is_shareable, SharedObjectProxy, share
 )
 from ._queues import (
     create as create_queue,
@@ -245,19 +245,3 @@ def call_in_thread(self, callable, /, *args, **kwargs):
         t = threading.Thread(target=self._call, args=(callable, args, kwargs))
         t.start()
         return t
-
-
-def _can_natively_share(obj):
-    if isinstance(obj, SharedObjectProxy):
-        return False
-
-    return _interpreters.is_shareable(obj)
-
-
-def share(obj):
-    """Wrap the object in a shareable object proxy that allows cross-interpreter
-    access.
-    """
-    if _can_natively_share(obj):
-        return obj
-    return _interpreters.share(obj)

Lib/test/test_interpreters/test_object_proxy.py

@@ -5,7 +5,7 @@
 
 # Raise SkipTest if subinterpreters not supported.
 import_helper.import_module("_interpreters")
-from concurrent.interpreters import share, SharedObjectProxy
+from concurrent.interpreters import NotShareableError, share, SharedObjectProxy
 from test.test_interpreters.utils import TestBase
 from threading import Barrier, Thread, Lock, local
 from concurrent import interpreters
@@ -287,6 +287,56 @@ def foo():
 
         self.assertTrue(called)
 
+    def test_proxy_reshare_does_not_copy(self):
+        class Test:
+            pass
+
+        proxy = share(Test())
+        reproxy = share(proxy)
+        self.assertIs(proxy, reproxy)
+
+    def test_object_share_method(self):
+        class Test:
+            def __share__(self):
+                return 42
+
+        shared = share(Test())
+        self.assertEqual(shared, 42)
+
+    def test_object_share_method_failure(self):
+        class Test:
+            def __share__(self):
+                return self
+
+        exception = RuntimeError("ouch")
+        class Evil:
+            def __share__(self):
+                raise exception
+
+        with self.assertRaises(NotShareableError):
+            share(Test())
+
+        with self.assertRaises(RuntimeError) as exc:
+            share(Evil())
+
+        self.assertIs(exc.exception, exception)
+
+    def test_proxy_manual_construction(self):
+        called = False
+
+        class Test:
+            def __init__(self):
+                self.attr = 24
+
+            def __share__(self):
+                nonlocal called
+                called = True
+                return 42
+
+        proxy = SharedObjectProxy(Test())
+        self.assertIsInstance(proxy, SharedObjectProxy)
+        self.assertFalse(called)
+        self.assertEqual(proxy.attr, 24)
 
 if __name__ == "__main__":
     unittest.main()

Modules/_interpretersmodule.c

@@ -2548,18 +2548,16 @@ _interpreters_capture_exception_impl(PyObject *module, PyObject *exc_arg)
 }
 
 static PyObject *
-call_share_method_steal(PyObject *method)
+call_share_method_steal(PyThreadState *tstate, PyObject *method)
 {
+    assert(tstate != NULL);
     assert(method != NULL);
     PyObject *result = PyObject_CallNoArgs(method);
     Py_DECREF(method);
     if (result == NULL) {
         return NULL;
     }
 
-    PyThreadState *tstate = _PyThreadState_GET();
-    assert(tstate != NULL);
-
     if (_PyObject_CheckXIData(tstate, result) < 0) {
         PyObject *exc = _PyErr_GetRaisedException(tstate);
         _PyXIData_FormatNotShareableError(tstate, "__share__() returned unshareable object: %R", result);
@@ -2586,12 +2584,18 @@ static PyObject *
 _interpreters_share(PyObject *module, PyObject *op)
 /*[clinic end generated code: output=e2ce861ae3b58508 input=5fb300b5598bb7d2]*/
 {
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (_PyObject_CheckXIData(tstate, op) == 0) {
+        return Py_NewRef(op);
+    }
+    PyErr_Clear();
+
     PyObject *share_method;
     if (PyObject_GetOptionalAttrString(op, "__share__", &share_method) < 0) {
         return NULL;
     }
     if (share_method != NULL) {
-        return call_share_method_steal(share_method /* stolen */);
+        return call_share_method_steal(tstate, share_method /* stolen */);
     }
 
     return _sharedobjectproxy_create(op, _PyInterpreterState_GET());