add callback disconnect by passing function

ianhi · ianhi · commit 3e7bedb6ca4b · 2025-12-12T12:28:57.000-05:00
diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -229,6 +229,9 @@ class CallbackRegistry:
         >>> callbacks.process('drink', 123)
         drink 123
 
+        >>> callbacks.disconnect_func('drink', ondrink)  # disconnect by func
+        >>> callbacks.process('drink', 123)      # nothing will be called
+
     In practice, one should always disconnect all callbacks when they are
     no longer needed to avoid dangling references (and thus memory leaks).
     However, real code in Matplotlib rarely does so, and due to its design,
@@ -349,6 +352,15 @@ def disconnect(self, cid):
         if len(self.callbacks[signal]) == 0:  # Clean up empty dicts
             del self.callbacks[signal]
 
+    def disconnect_func(self, signal, func):
+        """
+        Disconnect the callback for *func* registered to *signal*.
+
+        No error is raised if such a callback does not exist.
+        """
+        proxy = _weak_or_strong_ref(func, None)
+        self._remove_proxy(signal, proxy)
+
     def process(self, s, *args, **kwargs):
         """
         Process signal *s*.
diff --git a/lib/matplotlib/cbook.pyi b/lib/matplotlib/cbook.pyi
@@ -34,6 +34,7 @@ class CallbackRegistry:
     ) -> None: ...
     def connect(self, signal: Any, func: Callable) -> int: ...
     def disconnect(self, cid: int) -> None: ...
+    def disconnect_func(self, signal: Any, func: Callable) -> None: ...
     def process(self, s: Any, *args, **kwargs) -> None: ...
     def blocked(
         self, *, signal: Any | None = ...
diff --git a/lib/matplotlib/tests/test_cbook.py b/lib/matplotlib/tests/test_cbook.py
@@ -292,6 +292,73 @@ def test_callback_wrong_disconnect(self, pickle, cls):
         # check we still have callbacks registered
         self.is_not_empty()
 
+    @pytest.mark.parametrize('pickle', [True, False])
+    @pytest.mark.parametrize('cls', [Hashable, Unhashable])
+    def test_callback_disconnect_func(self, pickle, cls):
+        # ensure we start with an empty registry
+        self.is_empty()
+
+        # create a class for testing
+        mini_me = cls()
+
+        # test that we can add a callback
+        self.connect(self.signal, mini_me.dummy, pickle)
+        self.is_not_empty()
+
+        # disconnect by function reference
+        self.callbacks.disconnect_func(self.signal, mini_me.dummy)
+
+        # check we now have no callbacks registered
+        self.is_empty()
+
+    @pytest.mark.parametrize('pickle', [True, False])
+    @pytest.mark.parametrize('cls', [Hashable, Unhashable])
+    def test_callback_disconnect_func_wrong(self, pickle, cls):
+        # ensure we start with an empty registry
+        self.is_empty()
+
+        # create a class for testing
+        mini_me = cls()
+
+        # test that we can add a callback
+        self.connect(self.signal, mini_me.dummy, pickle)
+        self.is_not_empty()
+
+        # try to disconnect with wrong signal - should do nothing
+        self.callbacks.disconnect_func('wrong_signal', mini_me.dummy)
+
+        # check we still have callbacks registered
+        self.is_not_empty()
+
+        # try to disconnect with wrong function - should do nothing
+        mini_me2 = cls()
+        self.callbacks.disconnect_func(self.signal, mini_me2.dummy)
+
+        # check we still have callbacks registered
+        self.is_not_empty()
+
+    def test_callback_disconnect_func_redefined(self):
+        # Test that redefining a function name doesn't affect disconnect_func.
+        # When you redefine a function, it creates a new function object,
+        # so disconnect_func should not disconnect the original.
+        self.is_empty()
+
+        def func():
+            pass
+
+        self.callbacks.connect(self.signal, func)
+        self.is_not_empty()
+
+        # Redefine func - this creates a new function object
+        def func():
+            pass
+
+        # Try to disconnect with the redefined function
+        self.callbacks.disconnect_func(self.signal, func)
+
+        # Original callback should still be registered
+        self.is_not_empty()
+
     @pytest.mark.parametrize('pickle', [True, False])
     @pytest.mark.parametrize('cls', [Hashable, Unhashable])
     def test_registration_on_non_empty_registry(self, pickle, cls):
