Require calling a _BoundMethodProxy to get the underlying callable.

anntzer · anntzer · commit 28fd2d7a67f8 · 2018-02-15T11:39:43.000+01: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
@@ -30,7 +30,8 @@
 import traceback
 import types
 import warnings
-from weakref import ref, WeakKeyDictionary
+import weakref
+from weakref import WeakKeyDictionary, WeakMethod
 
 import numpy as np
 
@@ -145,111 +146,6 @@ def __call__(self, s):
         return int(s)
 
 
-class _BoundMethodProxy(object):
-    """
-    Our own proxy object which enables weak references to bound and unbound
-    methods and arbitrary callables. Pulls information about the function,
-    class, and instance out of a bound method. Stores a weak reference to the
-    instance to support garbage collection.
-
-    @organization: IBM Corporation
-    @copyright: Copyright (c) 2005, 2006 IBM Corporation
-    @license: The BSD License
-
-    Minor bugfixes by Michael Droettboom
-    """
-    def __init__(self, cb):
-        self._hash = hash(cb)
-        self._destroy_callbacks = []
-        try:
-            try:
-                if six.PY3:
-                    self.inst = ref(cb.__self__, self._destroy)
-                else:
-                    self.inst = ref(cb.im_self, self._destroy)
-            except TypeError:
-                self.inst = None
-            if six.PY3:
-                self.func = cb.__func__
-                self.klass = cb.__self__.__class__
-            else:
-                self.func = cb.im_func
-                self.klass = cb.im_class
-        except AttributeError:
-            self.inst = None
-            self.func = cb
-            self.klass = None
-
-    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
-
-    def __getstate__(self):
-        d = self.__dict__.copy()
-        # de-weak reference inst
-        inst = d['inst']
-        if inst is not None:
-            d['inst'] = inst()
-        return d
-
-    def __setstate__(self, statedict):
-        self.__dict__ = statedict
-        inst = statedict['inst']
-        # turn inst back into a weakref
-        if inst is not None:
-            self.inst = ref(inst)
-
-    def __call__(self, *args, **kwargs):
-        """
-        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())
-
-        else:
-            # not a bound method, just return the func
-            mtd = self.func
-        # invoke the callable and return the result
-        return mtd(*args, **kwargs)
-
-    def __eq__(self, other):
-        """
-        Compare the held function and instance with that held by
-        another proxy.
-        """
-        try:
-            if self.inst is None:
-                return self.func == other.func and other.inst is None
-            else:
-                return self.func == other.func and self.inst() == other.inst()
-        except Exception:
-            return False
-
-    def __ne__(self, other):
-        """
-        Inverse of __eq__.
-        """
-        return not self.__eq__(other)
-
-    def __hash__(self):
-        return self._hash
-
-
 def _exception_printer(exc):
     traceback.print_exc()
 
@@ -334,13 +230,11 @@ def connect(self, s, func):
         """Register *func* to be called when signal *s* is generated.
         """
         self._func_cid_map.setdefault(s, WeakKeyDictionary())
-        # Note proxy not needed in python 3.
-        # TODO rewrite this when support for python2.x gets dropped.
-        proxy = _BoundMethodProxy(func)
+        proxy = WeakMethod(func)
         if proxy in self._func_cid_map[s]:
             return self._func_cid_map[s][proxy]
 
-        proxy.add_destroy_callback(self._remove_proxy)
+        weakref.finalize(proxy, self._remove_proxy)
         self._cid += 1
         cid = self._cid
         self._func_cid_map[s][proxy] = cid
@@ -382,12 +276,13 @@ def process(self, s, *args, **kwargs):
         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:
@@ -1483,10 +1378,10 @@ class Grouper(object):
     def __init__(self, init=()):
         mapping = self._mapping = {}
         for x in init:
-            mapping[ref(x)] = [ref(x)]
+            mapping[weakref.ref(x)] = [weakref.ref(x)]
 
     def __contains__(self, item):
-        return ref(item) in self._mapping
+        return weakref.ref(item) in self._mapping
 
     def clean(self):
         """
@@ -1504,13 +1399,13 @@ def join(self, a, *args):
         arguments.
         """
         mapping = self._mapping
-        set_a = mapping.setdefault(ref(a), [ref(a)])
+        set_a = mapping.setdefault(weakref.ref(a), [weakref.ref(a)])
 
         for arg in args:
-            set_b = mapping.get(ref(arg))
+            set_b = mapping.get(weakref.ref(arg))
             if set_b is None:
-                set_a.append(ref(arg))
-                mapping[ref(arg)] = set_a
+                set_a.append(weakref.ref(arg))
+                mapping[weakref.ref(arg)] = set_a
             elif set_b is not set_a:
                 if len(set_b) > len(set_a):
                     set_a, set_b = set_b, set_a
@@ -1528,17 +1423,17 @@ def joined(self, a, b):
 
         mapping = self._mapping
         try:
-            return mapping[ref(a)] is mapping[ref(b)]
+            return mapping[weakref.ref(a)] is mapping[weakref.ref(b)]
         except KeyError:
             return False
 
     def remove(self, a):
         self.clean()
 
         mapping = self._mapping
-        seta = mapping.pop(ref(a), None)
+        seta = mapping.pop(weakref.ref(a), None)
         if seta is not None:
-            seta.remove(ref(a))
+            seta.remove(weakref.ref(a))
 
     def __iter__(self):
         """
@@ -1567,7 +1462,7 @@ def get_siblings(self, a):
         """
         self.clean()
 
-        siblings = self._mapping.get(ref(a), [ref(a)])
+        siblings = self._mapping.get(weakref.ref(a), [weakref.ref(a)])
         return [x() for x in siblings]
 
 
