Oct 24, 2024 · Oct 25, 2024 · Oct 25, 2024 · Oct 25, 2024
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
        """
        if timeout <= 0:
            timeout = np.inf
        timestep = 0.01
        counter = 0
        t_end = time.perf_counter() + timeout
        self._looping = True
        while self._looping andcounter * timestep < timeout:
        while self._looping andtime.perf_counter() < t_end:
            self.flush_events()
            time.sleep(timestep)
            counter += 1
            time.sleep(0.01)  # Pause for 10ms

    def stop_event_loop(self):
        """
diff --git a/lib/matplotlib/backends/backend_wx.py b/lib/matplotlib/backends/backend_wx.py
        if self._timer.IsRunning():
            self._timer_start()  # Restart with new interval.

    def _timer_set_single_shot(self):
        if self._timer.IsRunning():
            self._timer_start()  # Restart with new interval.


 @_api.deprecated(
    "2.0", name="wx", obj_type="backend", removal="the future",
diff --git a/lib/matplotlib/tests/test_backends_interactive.py b/lib/matplotlib/tests/test_backends_interactive.py


 def _impl_test_interactive_timers():
    # NOTE: We run the timer tests in parallel to avoid longer sequential
    #       delays which adds to the testing time. Add new tests to one of
    #       the current event loop iterations if possible.
    from unittest.mock import Mock
    import matplotlib.pyplot as plt

    fig = plt.figure()
    event_loop_time = 0.5  # in seconds

    # A timer with <1 millisecond gets converted to int and therefore 0
    # milliseconds, which the mac framework interprets as singleshot.
    # We only want singleshot if we specify that ourselves, otherwise we want
    # a repeating timer
    import os
    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
    fig = plt.figure()
    plt.pause(pause_time)
    timer = fig.canvas.new_timer(0.1)
    mock = Mock()
    timer.add_callback(mock)
    timer.start()
    plt.pause(pause_time)
    timer.stop()
    assert mock.call_count > 1

    # Now turn it into a single shot timer and verify only one gets triggered
    mock.call_count = 0
    timer.single_shot = True
    timer.start()
    plt.pause(pause_time)
    assert mock.call_count == 1

    # Make sure we can start the timer a second time
    timer.start()
    plt.pause(pause_time)
    assert mock.call_count == 2
    timer_repeating = fig.canvas.new_timer(0.1)
    mock_repeating = Mock()
    timer_repeating.add_callback(mock_repeating)
    timer_repeating.start()

    timer_single_shot = fig.canvas.new_timer(100)
    mock_single_shot = Mock()
    timer_single_shot.add_callback(mock_single_shot)
    # Start as a repeating timer then change to singleshot via the attribute
    timer_single_shot.start()
    timer_single_shot.single_shot = True

    fig.canvas.start_event_loop(event_loop_time)
    # NOTE: The timer is as fast as possible, but this is different between backends
    #       so we can't assert on the exact number but it should be faster than 100ms
    expected_100ms_calls = int(event_loop_time / 0.1)
    assert mock_repeating.call_count > expected_100ms_calls, \
        f"Expected more than {expected_100ms_calls} calls, " \
        f"got {mock_repeating.call_count}"
    assert mock_single_shot.call_count == 1, \
        f"Expected 1 call, got {mock_single_shot.call_count}"

    # Test updating the interval updates a running timer
    timer_repeating.interval = 100
    mock_repeating.call_count = 0
    # Make sure we can start the timer after stopping a singleshot timer
    timer_single_shot.stop()
    timer_single_shot.start()

    fig.canvas.start_event_loop(event_loop_time)
    assert 1 < mock_repeating.call_count <= expected_100ms_calls + 1, \
        f"Expected less than {expected_100ms_calls + 1} calls, " \
        "got {mock.call_count}"
    assert mock_single_shot.call_count == 2, \
        f"Expected 2 calls, got {mock_single_shot.call_count}"
    plt.close("all")


diff --git a/src/_macosx.m b/src/_macosx.m
    Py_RETURN_NONE;
 }

 static PyObject*
 Timer__timer_update(Timer* self)
 {
 // stop and invalidate a timer if it is already running and then create a new one
 // where the start() method retrieves the updated interval internally
 if (self->timer) {
 Timer__timer_stop_impl(self);
 gil_call_method((PyObject*)self,"_timer_start");
    }
    Py_RETURN_NONE;
 }

 staticvoid
 Timer_dealloc(Timer* self)
 {
        {"_timer_stop",
         (PyCFunction)Timer__timer_stop,
         METH_NOARGS},
        {"_timer_set_interval",
         (PyCFunction)Timer__timer_update,
         METH_NOARGS},
        {"_timer_set_single_shot",
         (PyCFunction)Timer__timer_update,
         METH_NOARGS},
        {}// sentinel
    },
 };
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2320,13 +2320,11 @@ def start_event_loop(self, timeout=0):
		"""
		if timeout <= 0:
		timeout = np.inf
		timestep = 0.01
		counter = 0
		t_end = time.perf_counter() + timeout
		self._looping = True
		while self._looping andcounter * timestep < timeout:
		while self._looping andtime.perf_counter() < t_end:
		self.flush_events()
		time.sleep(timestep)
		counter += 1
		time.sleep(0.01) # Pause for 10ms

		def stop_event_loop(self):
		"""
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -69,6 +69,10 @@ def _timer_set_interval(self):
		if self._timer.IsRunning():
		self._timer_start() # Restart with new interval.

		def _timer_set_single_shot(self):
		if self._timer.IsRunning():
		self._timer_start() # Restart with new interval.


		@_api.deprecated(
		"2.0", name="wx", obj_type="backend", removal="the future",
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -621,37 +621,54 @@ def test_blitting_events(env):


		def _impl_test_interactive_timers():
		# NOTE: We run the timer tests in parallel to avoid longer sequential
		# delays which adds to the testing time. Add new tests to one of
		# the current event loop iterations if possible.
		from unittest.mock import Mock
		import matplotlib.pyplot as plt

		fig = plt.figure()
		event_loop_time = 0.5 # in seconds

		# A timer with <1 millisecond gets converted to int and therefore 0
		# milliseconds, which the mac framework interprets as singleshot.
		# We only want singleshot if we specify that ourselves, otherwise we want
		# a repeating timer
		import os
		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
		fig = plt.figure()
		plt.pause(pause_time)
		timer = fig.canvas.new_timer(0.1)
		mock = Mock()
		timer.add_callback(mock)
		timer.start()
		plt.pause(pause_time)
		timer.stop()
		assert mock.call_count > 1

		# Now turn it into a single shot timer and verify only one gets triggered
		mock.call_count = 0
		timer.single_shot = True
		timer.start()
		plt.pause(pause_time)
		assert mock.call_count == 1

		# Make sure we can start the timer a second time
		timer.start()
		plt.pause(pause_time)
		assert mock.call_count == 2
		timer_repeating = fig.canvas.new_timer(0.1)
		mock_repeating = Mock()
		timer_repeating.add_callback(mock_repeating)
		timer_repeating.start()

		timer_single_shot = fig.canvas.new_timer(100)
		mock_single_shot = Mock()
		timer_single_shot.add_callback(mock_single_shot)
		# Start as a repeating timer then change to singleshot via the attribute
		timer_single_shot.start()
		timer_single_shot.single_shot = True

		fig.canvas.start_event_loop(event_loop_time)
		# NOTE: The timer is as fast as possible, but this is different between backends
		# so we can't assert on the exact number but it should be faster than 100ms
		expected_100ms_calls = int(event_loop_time / 0.1)
		assert mock_repeating.call_count > expected_100ms_calls, \
		f"Expected more than {expected_100ms_calls} calls, " \
		f"got {mock_repeating.call_count}"
		assert mock_single_shot.call_count == 1, \
		f"Expected 1 call, got {mock_single_shot.call_count}"

		# Test updating the interval updates a running timer
		timer_repeating.interval = 100
		mock_repeating.call_count = 0
		# Make sure we can start the timer after stopping a singleshot timer
		timer_single_shot.stop()
		timer_single_shot.start()

		fig.canvas.start_event_loop(event_loop_time)
		assert 1 < mock_repeating.call_count <= expected_100ms_calls + 1, \
		f"Expected less than {expected_100ms_calls + 1} calls, " \
		"got {mock.call_count}"
		assert mock_single_shot.call_count == 2, \
		f"Expected 2 calls, got {mock_single_shot.call_count}"
		plt.close("all")


Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1789,6 +1789,18 @@ - (void)flagsChanged:(NSEvent *)event
		Py_RETURN_NONE;
		}

		static PyObject*
		Timer__timer_update(Timer* self)
		{
		// stop and invalidate a timer if it is already running and then create a new one
		// where the start() method retrieves the updated interval internally
		if (self->timer) {
		Timer__timer_stop_impl(self);
		gil_call_method((PyObject*)self,"_timer_start");
		}
		Py_RETURN_NONE;
		}

		staticvoid
		Timer_dealloc(Timer* self)
		{
Expand All		@@ -1815,6 +1827,12 @@ - (void)flagsChanged:(NSEvent *)event
		{"_timer_stop",
		(PyCFunction)Timer__timer_stop,
		METH_NOARGS},
		{"_timer_set_interval",
		(PyCFunction)Timer__timer_update,
		METH_NOARGS},
		{"_timer_set_single_shot",
		(PyCFunction)Timer__timer_update,
		METH_NOARGS},
		{}// sentinel
		},
		};
Expand Down