matplotlib · greglucas · Oct 25, 2024 · Oct 25, 2024 · Oct 25, 2024 · Oct 25, 2024
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -1041,7 +1041,9 @@ def __init__(self, interval=None, callbacks=None):
             and `~.TimerBase.remove_callback` can be used.
         """
         self.callbacks = [] if callbacks is None else callbacks.copy()
-        # Set .interval and not ._interval to go through the property setter.
+        # Go through the property setters for validation and updates
+        self._interval = None
+        self._single = None
         self.interval = 1000 if interval is None else interval
         self.single_shot = False
 
@@ -1085,8 +1087,9 @@ def interval(self, interval):
         # milliseconds, and some error or give warnings.
         # Some backends also fail when interval == 0, so ensure >= 1 msec
         interval = max(int(interval), 1)
-        self._interval = interval
-        self._timer_set_interval()
+        if interval != self._interval:
+            self._interval = interval
+            self._timer_set_interval()
 
     @property
     def single_shot(self):
@@ -1095,8 +1098,9 @@ def single_shot(self):
 
     @single_shot.setter
     def single_shot(self, ss):
-        self._single = ss
-        self._timer_set_single_shot()
+        if ss != self._single:
+            self._single = ss
+            self._timer_set_single_shot()
 
     def add_callback(self, func, *args, **kwargs):
         """

diff --git a/lib/matplotlib/backends/_backend_tk.py b/lib/matplotlib/backends/_backend_tk.py
@@ -6,6 +6,7 @@
 import os.path
 import pathlib
 import sys
+import time
 import tkinter as tk
 import tkinter.filedialog
 import tkinter.font
@@ -132,21 +133,40 @@ def __init__(self, parent, *args, **kwargs):
     def _timer_start(self):
         self._timer_stop()
         self._timer = self.parent.after(self._interval, self._on_timer)
+        # Keep track of the firing time for repeating timers since
+        # we have to do this manually in Tk
+        self._timer_start_count = time.perf_counter_ns()
 
     def _timer_stop(self):
         if self._timer is not None:
             self.parent.after_cancel(self._timer)
         self._timer = None
 
     def _on_timer(self):
+        # We want to measure the time spent in the callback, so we need to
+        # record the time before calling the base class method.
+        timer_fire_ms = (time.perf_counter_ns() - self._timer_start_count) // 1_000_000
         super()._on_timer()
         # Tk after() is only a single shot, so we need to add code here to
         # reset the timer if we're not operating in single shot mode.  However,
         # if _timer is None, this means that _timer_stop has been called; so
         # don't recreate the timer in that case.
         if not self._single and self._timer:
             if self._interval > 0:
-                self._timer = self.parent.after(self._interval, self._on_timer)
+                # We want to adjust our fire time independent of the time
+                # spent in the callback and not drift over time, so reference
+                # to the start count.
+                after_callback_ms = ((time.perf_counter_ns() - self._timer_start_count)
+                                     // 1_000_000)
+                if after_callback_ms - timer_fire_ms < self._interval:
+                    next_interval = self._interval - after_callback_ms % self._interval
+                    # minimum of 1ms
+                    next_interval = max(1, next_interval)
+                else:
+                    # Account for the callback being longer than the interval, where
+                    # we really want to fire the next timer as soon as possible.
+                    next_interval = 1
+                self._timer = self.parent.after(next_interval, self._on_timer)
             else:
                 # Edge case: Tcl after 0 *prepends* events to the queue
                 # so a 0 interval does not allow any other events to run.

diff --git a/lib/matplotlib/tests/test_backend_bases.py b/lib/matplotlib/tests/test_backend_bases.py
@@ -1,9 +1,10 @@
 import importlib
+from unittest.mock import patch
 
 from matplotlib import path, transforms
 from matplotlib.backend_bases import (
     FigureCanvasBase, KeyEvent, LocationEvent, MouseButton, MouseEvent,
-    NavigationToolbar2, RendererBase)
+    NavigationToolbar2, RendererBase, TimerBase)
 from matplotlib.backend_tools import RubberbandBase
 from matplotlib.figure import Figure
 from matplotlib.testing._markers import needs_pgf_xelatex
@@ -581,3 +582,24 @@ def test_interactive_pan_zoom_events(tool, button, patch_vis, forward_nav, t_s):
         # Check if twin-axes are properly triggered
         assert ax_t.get_xlim() == pytest.approx(ax_t_twin.get_xlim(), abs=0.15)
         assert ax_b.get_xlim() == pytest.approx(ax_b_twin.get_xlim(), abs=0.15)
+
+
+def test_timer_properties():
+    # Setting a property to the same value should not trigger the
+    # private setter call again.
+    timer = TimerBase(100)
+    with patch.object(timer, '_timer_set_interval') as mock:
+        timer.interval = 200
+        mock.assert_called_once()
+        assert timer.interval == 200
+        timer.interval = 200
+        # Make sure it wasn't called again
+        mock.assert_called_once()
+
+    with patch.object(timer, '_timer_set_single_shot') as mock:
+        timer.single_shot = True
+        mock.assert_called_once()
+        assert timer._single
+        timer.single_shot = True
+        # Make sure it wasn't called again
+        mock.assert_called_once()
diff --git a/lib/matplotlib/tests/test_backends_interactive.py b/lib/matplotlib/tests/test_backends_interactive.py
@@ -626,8 +626,10 @@ def _impl_test_interactive_timers():
     # We only want singleshot if we specify that ourselves, otherwise we want
     # a repeating timer
     import os
+    import time
     from unittest.mock import Mock
     import matplotlib.pyplot as plt
+
     # increase pause duration on CI to let things spin up
     # particularly relevant for gtk3cairo
     pause_time = 2 if os.getenv("CI") else 0.5
@@ -637,9 +639,26 @@ def _impl_test_interactive_timers():
     mock = Mock()
     timer.add_callback(mock)
     timer.start()
+
+    mock_slow_callback = Mock()
+    def slow_callback():
+        time.sleep(0.075)  # 75ms
+        mock_slow_callback()
+    # 100ms timer triggers and the callback takes 75ms to run
+    # Make sure we don't drift and get called on every 100ms
+    # interval and not every 175ms
+    timer_slow_callback = fig.canvas.new_timer(100)
+    timer_slow_callback.add_callback(slow_callback)
+    timer_slow_callback.start()
+
     plt.pause(pause_time)
     timer.stop()
+    timer_slow_callback.stop()
     assert mock.call_count > 1
+    expected_slow_calls = pause_time * 10 - 1
+    assert expected_slow_calls <= mock_slow_callback.call_count, \
+        f"Expected at least {expected_slow_calls} calls, " \
+        f"got {mock_slow_callback.call_count}"
 
     # Now turn it into a single shot timer and verify only one gets triggered
     mock.call_count = 0