Make autojump/autojump_threshold methods of abc.Clock

Author: fjarri

src/trio/_abc.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from math import inf
 import socket
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Generic, TypeVar
@@ -65,6 +66,15 @@ def deadline_to_sleep_time(self, deadline: float) -> float:
 
         """
 
+    @property
+    def autojump_threshold(self) -> float:
+        return inf
+
+    def autojump(self) -> None:
+        # If `autojump_threshold()` has the default implementation (returning `inf`),
+        # this will never be called.
+        raise NotImplementedError
+
 
 class Instrument(ABC):  # noqa: B024  # conceptually is ABC
     """The interface for run loop instrumentation.

src/trio/_core/_mock_clock.py

@@ -105,26 +105,17 @@ def autojump_threshold(self, new_autojump_threshold: float) -> None:
         self._autojump_threshold = float(new_autojump_threshold)
         self._try_resync_autojump_threshold()
 
-    # runner.clock_autojump_threshold is an internal API that isn't easily
-    # usable by custom third-party Clock objects. If you need access to this
-    # functionality, let us know, and we'll figure out how to make a public
-    # API. Discussion:
-    #
-    #     https://github.com/python-trio/trio/issues/1587
     def _try_resync_autojump_threshold(self) -> None:
         try:
             runner = GLOBAL_RUN_CONTEXT.runner
             if runner.is_guest:
                 runner.force_guest_tick_asap()
         except AttributeError:
             pass
-        else:
-            if runner.clock is self:
-                runner.clock_autojump_threshold = self._autojump_threshold
 
     # Invoked by the run loop when runner.clock_autojump_threshold is
     # exceeded.
-    def _autojump(self) -> None:
+    def autojump(self) -> None:
         statistics = _core.current_statistics()
         jump = statistics.seconds_to_next_deadline
         if 0 < jump < inf:
@@ -136,7 +127,7 @@ def _real_to_virtual(self, real: float) -> float:
         return self._virtual_base + virtual_offset
 
     def start_clock(self) -> None:
-        self._try_resync_autojump_threshold()
+        pass
 
     def current_time(self) -> float:
         return self._real_to_virtual(self._real_clock())

src/trio/_core/_run.py

@@ -1816,9 +1816,6 @@ class Runner:  # type: ignore[explicit-any]
     trio_token: TrioToken | None = None
     asyncgens: AsyncGenerators = attrs.Factory(AsyncGenerators)
 
-    # If everything goes idle for this long, we call clock._autojump()
-    clock_autojump_threshold: float = inf
-
     # Guest mode stuff
     is_guest: bool = False
     guest_tick_scheduled: bool = False
@@ -2758,8 +2755,8 @@ def unrolled_run(
             # We use 'elif' here because if there are tasks in
             # wait_all_tasks_blocked, then those tasks will wake up without
             # jumping the clock, so we don't need to autojump.
-            elif runner.clock_autojump_threshold < timeout:
-                timeout = runner.clock_autojump_threshold
+            elif runner.clock.autojump_threshold < timeout:
+                timeout = runner.clock.autojump_threshold
                 idle_primed = IdlePrimedTypes.AUTOJUMP_CLOCK
 
             if "before_io_wait" in runner.instruments:
@@ -2810,8 +2807,7 @@ def unrolled_run(
                             break
                 else:
                     assert idle_primed is IdlePrimedTypes.AUTOJUMP_CLOCK
-                    assert isinstance(runner.clock, _core.MockClock)
-                    runner.clock._autojump()
+                    runner.clock.autojump()
 
             # Process all runnable tasks, but only the ones that are already
             # runnable now. Anything that becomes runnable during this cycle

src/trio/_core/_tests/test_guest_mode.py

@@ -187,6 +187,13 @@ def current_time(self) -> float:
         def deadline_to_sleep_time(self, deadline: float) -> float:
             raise NotImplementedError()
 
+        @property
+        def autojump_threshold(self) -> float:
+            raise NotImplementedError()
+
+        def autojump(self) -> None:
+            raise NotImplementedError()
+
     def after_start_never_runs() -> None:  # pragma: no cover
         pytest.fail("shouldn't get here")
 

src/trio/_core/_tests/test_mock_clock.py

@@ -181,13 +181,13 @@ async def waiter() -> None:
 async def test_initialization_doesnt_mutate_runner() -> None:
     before = (
         GLOBAL_RUN_CONTEXT.runner.clock,
-        GLOBAL_RUN_CONTEXT.runner.clock_autojump_threshold,
+        GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
     )
 
     MockClock(autojump_threshold=2, rate=3)
 
     after = (
         GLOBAL_RUN_CONTEXT.runner.clock,
-        GLOBAL_RUN_CONTEXT.runner.clock_autojump_threshold,
+        GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
     )
     assert before == after