Removed registered Proxy Objects from SharedMemoryManager.

Author: applio

Doc/library/multiprocessing.shared_memory.rst

@@ -205,9 +205,7 @@ same ``numpy.ndarray`` from two distinct Python shells:
 
    This class provides methods for creating and returning :class:`SharedMemory`
    instances and for creating a list-like object (:class:`ShareableList`)
-   backed by shared memory.  It also provides methods that create and
-   return :ref:`multiprocessing-proxy_objects` that support synchronization
-   across processes (i.e. multi-process-safe locks and semaphores).
+   backed by shared memory.
 
    Refer to :class:`multiprocessing.managers.BaseManager` for a description
    of the inherited *address* and *authkey* optional input arguments and how
@@ -224,38 +222,6 @@ same ``numpy.ndarray`` from two distinct Python shells:
       Create and return a new :class:`ShareableList` object, initialized
       by the values from the input ``sequence``.
 
-   .. method:: Barrier(parties[, action[, timeout]])
-
-      Create a shared :class:`threading.Barrier` object and return a
-      proxy for it.
-
-   .. method:: BoundedSemaphore([value])
-
-      Create a shared :class:`threading.BoundedSemaphore` object and return
-      a proxy for it.
-
-   .. method:: Condition([lock])
-
-      Create a shared :class:`threading.Condition` object and return a proxy
-      for it.  The optional input *lock* supports a proxy for a
-      :class:`threading.Lock` or :class:`threading.RLock` object.
-
-   .. method:: Event()
-
-      Create a shared :class:`threading.Event` object and return a proxy for it.
-
-   .. method:: Lock()
-
-      Create a shared :class:`threading.Lock` object and return a proxy for it.
-
-   .. method:: RLock()
-
-      Create a shared :class:`threading.RLock` object and return a proxy for it.
-
-   .. method:: Semaphore([value])
-
-      Create a shared :class:`threading.Semaphore` object and return a proxy
-      for it.
 
 The following example demonstrates the basic mechanisms of a
 :class:`SharedMemoryManager`:

Lib/multiprocessing/shared_memory.py

@@ -12,13 +12,11 @@
 
 from functools import reduce
 import mmap
-from .managers import dispatch, BaseManager, Server, State, ProcessError, \
-                      BarrierProxy, AcquirerProxy, ConditionProxy, EventProxy
+from .managers import dispatch, BaseManager, Server, State, ProcessError
 from . import util
 import os
 import struct
 import sys
-import threading
 import secrets
 try:
     import  _posixshmem
@@ -835,15 +833,3 @@ def ShareableList(self, sequence):
                 sl.shm.unlink()
                 raise e
         return sl
-
-SharedMemoryManager.register('Barrier', threading.Barrier, BarrierProxy)
-SharedMemoryManager.register(
-    'BoundedSemaphore',
-    threading.BoundedSemaphore,
-    AcquirerProxy
-)
-SharedMemoryManager.register('Condition', threading.Condition, ConditionProxy)
-SharedMemoryManager.register('Event', threading.Event, EventProxy)
-SharedMemoryManager.register('Lock', threading.Lock, AcquirerProxy)
-SharedMemoryManager.register('RLock', threading.RLock, AcquirerProxy)
-SharedMemoryManager.register('Semaphore', threading.Semaphore, AcquirerProxy)

Lib/test/_test_multiprocessing.py

@@ -3751,9 +3751,7 @@ def test_shared_memory_SharedMemoryManager_basics(self):
 
         with shared_memory.SharedMemoryManager() as smm2:
             sl = smm2.ShareableList("howdy")
-            unnecessary_lock = smm2.Lock()
-            with unnecessary_lock:
-                shm = smm2.SharedMemory(size=128)
+            shm = smm2.SharedMemory(size=128)
             held_name = sl.shm.name
         if sys.platform != "win32":
             with self.assertRaises(FileNotFoundError):
@@ -4944,9 +4942,29 @@ def is_alive(self):
             any(process.is_alive() for process in forked_processes))
 
 
-class _MixinTestCommonManagerTypes(object):
+class TestSyncManagerTypes(unittest.TestCase):
+    """Test all the types which can be shared between a parent and a
+    child process by using a manager which acts as an intermediary
+    between them.
+
+    In the following unit-tests the base type is created in the parent
+    process, the @classmethod represents the worker process and the
+    shared object is readable and editable between the two.
+
+    # The child.
+    @classmethod
+    def _test_list(cls, obj):
+        assert obj[0] == 5
+        assert obj.append(6)
 
-    manager_class = None
+    # The parent.
+    def test_list(self):
+        o = self.manager.list()
+        o.append(5)
+        self.run_worker(self._test_list, o)
+        assert o[1] == 6
+    """
+    manager_class = multiprocessing.managers.SyncManager
 
     def setUp(self):
         self.manager = self.manager_class()
@@ -5056,31 +5074,6 @@ def test_barrier(self):
         o = self.manager.Barrier(5)
         self.run_worker(self._test_barrier, o)
 
-
-class TestSyncManagerTypes(_MixinTestCommonManagerTypes, unittest.TestCase):
-    """Test all the types which can be shared between a parent and a
-    child process by using a manager which acts as an intermediary
-    between them.
-
-    In the following unit-tests the base type is created in the parent
-    process, the @classmethod represents the worker process and the
-    shared object is readable and editable between the two.
-
-    # The child.
-    @classmethod
-    def _test_list(cls, obj):
-        assert obj[0] == 5
-        assert obj.append(6)
-
-    # The parent.
-    def test_list(self):
-        o = self.manager.list()
-        o.append(5)
-        self.run_worker(self._test_list, o)
-        assert o[1] == 6
-    """
-    manager_class = multiprocessing.managers.SyncManager
-
     @classmethod
     def _test_pool(cls, obj):
         # TODO: fix https://bugs.python.org/issue35919
@@ -5186,20 +5179,6 @@ def test_namespace(self):
         self.run_worker(self._test_namespace, o)
 
 
-try:
-    import multiprocessing.shared_memory
-except ImportError:
-    @unittest.skip("SharedMemoryManager not available on this platform")
-    class TestSharedMemoryManagerTypes(_MixinTestCommonManagerTypes,
-                                       unittest.TestCase):
-        pass
-else:
-    class TestSharedMemoryManagerTypes(_MixinTestCommonManagerTypes,
-                                       unittest.TestCase):
-        """Same as above but by using SharedMemoryManager."""
-        manager_class = multiprocessing.shared_memory.SharedMemoryManager
-
-
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         # Just make sure names in blacklist are excluded