Require calling a _BoundMethodProxy to get the underlying callable.

anntzer · anntzer · commit bef9d16403f2 · 2017-08-23T19:57:23.000-07:00
Code that used to call `_proxy(...)` now needs to call `_proxy()(...)`.

Instead of catching a ReferenceError, that could be either raised by a
failure to dereference the proxy, or by the underlying callable, one can
now check that `_proxy()` does not return None (to distinguish between
the two cases).

This is the same design as the stdlib's WeakMethod.
diff --git a/lib/matplotlib/cbook/__init__.py b/lib/matplotlib/cbook/__init__.py
@@ -183,11 +183,10 @@ def add_destroy_callback(self, callback):
         self._destroy_callbacks.append(_BoundMethodProxy(callback))
 
     def _destroy(self, wk):
-        for callback in self._destroy_callbacks:
-            try:
-                callback(self)
-            except ReferenceError:
-                pass
+        for ref in self._destroy_callbacks:
+            func = ref()
+            if func is not None:
+                func(self)
 
     def __getstate__(self):
         d = self.__dict__.copy()
@@ -205,26 +204,19 @@ def __setstate__(self, statedict):
             self.inst = ref(inst)
 
     def __call__(self, *args, **kwargs):
+        """Reconstructs the weakref'd callable, or None if the target is dead.
         """
-        Proxy for a call to the weak referenced object. Take
-        arbitrary params to pass to the callable.
-
-        Raises `ReferenceError`: When the weak reference refers to
-        a dead object
-        """
-        if self.inst is not None and self.inst() is None:
-            raise ReferenceError
-        elif self.inst is not None:
-            # build a new instance method with a strong reference to the
-            # instance
-
-            mtd = types.MethodType(self.func, self.inst())
-
+        if self.inst:
+            obj = self.inst()
+            if obj is None:
+                return None
+            else:
+                # build a new instance method with a strong reference to the
+                # instance
+                return types.MethodType(self.func, self.inst())
         else:
             # not a bound method, just return the func
-            mtd = self.func
-        # invoke the callable and return the result
-        return mtd(*args, **kwargs)
+            return self.func
 
     def __eq__(self, other):
         """
@@ -383,12 +375,13 @@ def process(self, s, *args, **kwargs):
         process signal `s`.  All of the functions registered to receive
         callbacks on `s` will be called with ``**args`` and ``**kwargs``
         """
-        if s in self.callbacks:
-            for cid, proxy in list(six.iteritems(self.callbacks[s])):
+        for ref in list(self.callbacks.get(s, {}).values()):
+            func = ref()
+            if func is None:
+                self._remove_proxy(ref)
+            else:
                 try:
-                    proxy(*args, **kwargs)
-                except ReferenceError:
-                    self._remove_proxy(proxy)
+                    func(*args, **kwargs)
                 # this does not capture KeyboardInterrupt, SystemExit,
                 # and GeneratorExit
                 except Exception as exc:
