Convert singleton object to a noremal object.

Author: note35

Lib/concurrent/interpreters/_crossinterp.py

@@ -5,30 +5,6 @@ class ItemInterpreterDestroyed(Exception):
     """Raised when trying to get an item whose interpreter was destroyed."""
 
 
-class classonly:
-    """A non-data descriptor that makes a value only visible on the class.
-
-    This is like the "classmethod" builtin, but does not show up on
-    instances of the class.  It may be used as a decorator.
-    """
-
-    def __init__(self, value):
-        self.value = value
-        self.getter = classmethod(value).__get__
-        self.name = None
-
-    def __set_name__(self, cls, name):
-        if self.name is not None:
-            raise TypeError('already used')
-        self.name = name
-
-    def __get__(self, obj, cls):
-        if obj is not None:
-            raise AttributeError(self.name)
-        # called on the class
-        return self.getter(None, cls)
-
-
 class UnboundItem:
     """Represents a cross-interpreter item no longer bound to an interpreter.
 
@@ -37,37 +13,9 @@ class UnboundItem:
     """
 
     __slots__ = ()
-
-    @classonly
-    def singleton(cls, kind, module, name='UNBOUND'):
-        doc = cls.__doc__
-        if doc:
-            doc = doc.replace(
-                'cross-interpreter container', kind,
-            ).replace(
-                'cross-interpreter', kind,
-            )
-        subclass = type(
-            f'Unbound{kind.capitalize()}Item',
-            (cls,),
-            {
-                "_MODULE": module,
-                "_NAME": name,
-                "__doc__": doc,
-            },
-        )
-        return object.__new__(subclass)
-
     _MODULE = __name__
     _NAME = 'UNBOUND'
 
-    def __new__(cls):
-        raise Exception(f'use {cls._MODULE}.{cls._NAME}')
-
-    def __repr__(self):
-        return f'{self._MODULE}.{self._NAME}'
-#        return f'interpreters._queues.UNBOUND'
-
     def __hash__(self):
         return hash((self._NAME, self._MODULE))
 
@@ -79,8 +27,12 @@ def __eq__(self, other):
             return True
         return repr(other) == repr(self)
 
+    def __repr__(self):
+        return f'{self._MODULE}.{self._NAME}'
+#        return f'interpreters._queues.UNBOUND'
+
 
-UNBOUND = object.__new__(UnboundItem)
+UNBOUND = UnboundItem()
 UNBOUND_ERROR = object()
 UNBOUND_REMOVE = object()
 

Lib/test/support/channels.py

@@ -10,7 +10,7 @@
     ChannelEmptyError, ChannelNotEmptyError,  # noqa: F401
 )
 from concurrent.interpreters._crossinterp import (
-    UNBOUND_ERROR, UNBOUND_REMOVE,
+    UNBOUND, UNBOUND_ERROR, UNBOUND_REMOVE,
 )
 
 
@@ -28,9 +28,6 @@ class ItemInterpreterDestroyed(ChannelError,
     """Raised from get() and get_nowait()."""
 
 
-UNBOUND = _crossinterp.UnboundItem.singleton('queue', __name__)
-
-
 def _serialize_unbound(unbound):
     if unbound is UNBOUND:
         unbound = _crossinterp.UNBOUND

Lib/test/test_concurrent_futures/test_interpreter_pool.py

@@ -516,6 +516,27 @@ def get_thread_name():
         self.assertStartsWith(self.executor.submit(get_thread_name).result(),
                               "InterpreterPoolExecutor-"[:15])
 
+    def test_cross_interpreter_unbound_identity(self):
+        # Prepare shared queues.
+        input_q = interpreters.create_queue()
+        input_q.put(queues.UNBOUND)
+        result_q = interpreters.create_queue()
+
+        # Create a sub-interpreter.
+        interp = interpreters.create()
+        interp.prepare_main({"input_q": input_q, "result_q": result_q})
+
+        # Run and compare the items in queue.
+        interp.exec("""
+from concurrent.interpreters import _queues as queues
+obj = input_q.get()
+is_identical = (obj is queues.UNBOUND)
+result_q.put(is_identical)
+""")
+        is_identical = result_q.get()
+        self.assertTrue(is_identical, "UNBOUND identity mismatch across interpreters")
+
+
 class AsyncioTest(InterpretersMixin, testasyncio_utils.TestCase):
 
     @classmethod