🔧 build(deps): refresh CI and docs tools (#904)

Co-authored-by: Bernát Gábor <gaborjbernat@gmail.com>
Signed-off-by: dependabot[bot] <support@github.com>

Author: dependabot[bot]

.github/workflows/codeql.yaml

@@ -27,7 +27,7 @@ jobs:
         with:
           persist-credentials: false
       - name: "🛡️ Initialize CodeQL"
-        uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
         with:
           languages: ${{ matrix.language }}
           build-mode: none
@@ -36,6 +36,6 @@ jobs:
             paths-ignore:
               - tests
       - name: "🛡️ Analyze"
-        uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
         with:
           category: "/language:${{ matrix.language }}"

.pre-commit-config.yaml

@@ -9,7 +9,7 @@ repos:
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0494aa7fa1314e98913a41227d8f0a515b2c1049 # frozen: 0.38.2
+    rev: a76b92851fc9eede9f9bc4073eb55202f34eb0df # frozen: 0.39.0
     hooks:
       - id: check-github-workflows
         args: ["--verbose"]
@@ -26,7 +26,7 @@ repos:
     hooks:
       - id: pyproject-fmt
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "38bfb07c0c64c304f47eb52090f8288150c77730" # frozen: v0.17.1
+    rev: "25bcf95026b96e2dd3c0aec3090c3d6ef6ca2e6c" # frozen: v0.17.3
     hooks:
       - id: ruff-format
       - id: ruff-check
@@ -56,7 +56,7 @@ repos:
         files: ^docs/changelog[.]rst$
         args: ["-l", "120"]
         additional_dependencies:
-          - "sphinx==9.1.1"
+          - "sphinx==9.2.0"
   - repo: https://github.com/zizmorcore/zizmor-pre-commit
     rev: c92afdf2c6ca336aaa8f39e2bd8d48f62dbd8e1f # frozen: v1.31.1
     hooks:

tests/soft_rw/test_soft_rw_sync.py

@@ -14,6 +14,7 @@
 from functools import partial
 from multiprocessing import Event, Process
 from pathlib import Path
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Final, Literal
 
 import pytest
@@ -942,11 +943,10 @@ def test_writer_evicted_while_draining_queues_behind_its_evictor(
     reader = _make_lock(lock_file, heartbeat_interval=10, stale_threshold=40)
     reader.acquire_read(timeout=2)
     writer = _make_lock(lock_file, heartbeat_interval=10, stale_threshold=40)
-    real_sleep = time.sleep
     swapped = threading.Event()
     peer: list[str] = []
 
-    def hook(seconds: float) -> None:  # ruff:ignore[unused-function-argument]  # replaces time.sleep; the duration is irrelevant to the swap
+    def hook(_seconds: float) -> None:
         if swapped.is_set():
             raise Timeout(lock_file)
         swapped.set()
@@ -959,14 +959,18 @@ def hook(seconds: float) -> None:  # ruff:ignore[unused-function-argument]  # re
         assert log.commit(Snapshot(generation=latest.generation + 1, writer=peer[0], readers=frozenset()))
         reader.release()
 
-    monkeypatch.setattr(sync_mod.time, "sleep", hook)
+    monkeypatch.setattr(
+        sync_mod,
+        "time",
+        SimpleNamespace(monotonic=time.monotonic, perf_counter=time.perf_counter, sleep=hook),
+    )
     try:
         with pytest.raises(Timeout):
             writer.acquire_write(timeout=30)
         assert swapped.is_set()
         assert _state(lock_file).writer == peer[0]
     finally:
-        monkeypatch.setattr(sync_mod.time, "sleep", real_sleep)
+        monkeypatch.setattr(sync_mod, "time", time)
         writer.close()
         reader.close()
 
@@ -1749,7 +1753,14 @@ def sleep(seconds: float) -> None:
         assert 0 < seconds <= timeout
         real_sleep(seconds)
 
-    mocker.patch("time.sleep", autospec=True, side_effect=sleep)
+    mocker.patch(
+        "filelock._soft_rw._sync.time",
+        new=SimpleNamespace(
+            monotonic=time.monotonic,
+            perf_counter=time.perf_counter,
+            sleep=mocker.create_autospec(time.sleep, side_effect=sleep),
+        ),
+    )
     with closing(SoftReadWriteLock(lock_file, timeout=timeout, blocking=blocking, poll_interval=10)) as lock:
         acquire: Final = lock.acquire_read if mode == "read" else lock.acquire_write
         with pytest.raises(Timeout) as caught:

tests/test_filelock.py

@@ -25,7 +25,7 @@
 from pkgutil import resolve_name
 from queue import Queue
 from stat import S_IMODE, S_IWGRP, S_IWOTH, S_IWUSR, filemode
-from types import CodeType, FrameType, TracebackType
+from types import CodeType, FrameType, SimpleNamespace, TracebackType
 from typing import TYPE_CHECKING, Any, Final, Literal, cast, get_args
 from uuid import uuid4
 from weakref import WeakValueDictionary
@@ -64,6 +64,7 @@
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator, Iterator
+    from unittest.mock import Mock
 
     from _typeshed import Unused
     from pytest_mock import MockerFixture
@@ -729,48 +730,52 @@ def test_default_poll_interval(lock_type: type[BaseFileLock], tmp_path: Path) ->
 
 
 @pytest.fixture
-def steady_clock(mocker: MockerFixture) -> None:
+def steady_clock(mocker: MockerFixture) -> Mock:
     # These tests assert the sleep the lock asked for. The lock caps that sleep at the time left before its timeout, so
     # a stall on a loaded machine between the start and the first poll would shorten it. A clock that advances 10 ms
     # per reading keeps the first poll inside the timeout regardless of load.
-    mocker.patch("filelock._api.time.perf_counter", side_effect=(reading / 100 for reading in count()))
+    sleep_mock: Final = mocker.create_autospec(time.sleep)
+    mocker.patch(
+        "filelock._api.time",
+        new=SimpleNamespace(
+            perf_counter=mocker.create_autospec(time.perf_counter, side_effect=(reading / 100 for reading in count())),
+            sleep=sleep_mock,
+        ),
+    )
+    return sleep_mock
 
 
-@pytest.mark.usefixtures("steady_clock")
 @pytest.mark.parametrize("lock_type", [FileLock, SoftFileLock])
 def test_poll_interval_used_by_context_manager(
-    lock_type: type[BaseFileLock], tmp_path: Path, mocker: MockerFixture
+    lock_type: type[BaseFileLock], tmp_path: Path, steady_clock: Mock
 ) -> None:
     lock_path = tmp_path / "a"
     lock_1 = lock_type(str(lock_path))
     lock_2 = lock_type(str(lock_path), timeout=0.2, poll_interval=0.05)
 
     lock_1.acquire()
-    sleep_mock = mocker.patch("filelock._api.time.sleep")
     with pytest.raises(Timeout):
         lock_2.acquire()
-    sleep_mock.assert_any_call(0.05)
+    steady_clock.assert_any_call(0.05)
 
-    sleep_mock.reset_mock()
+    steady_clock.reset_mock()
     lock_2.poll_interval = 0.1
     with pytest.raises(Timeout):
         lock_2.acquire()
-    sleep_mock.assert_any_call(0.1)
+    steady_clock.assert_any_call(0.1)
     lock_1.release()
 
 
-@pytest.mark.usefixtures("steady_clock")
 @pytest.mark.parametrize("lock_type", [FileLock, SoftFileLock])
-def test_poll_interval_acquire_override(lock_type: type[BaseFileLock], tmp_path: Path, mocker: MockerFixture) -> None:
+def test_poll_interval_acquire_override(lock_type: type[BaseFileLock], tmp_path: Path, steady_clock: Mock) -> None:
     lock_path = tmp_path / "a"
     lock_1 = lock_type(str(lock_path))
     lock_2 = lock_type(str(lock_path), timeout=0.2, poll_interval=0.05)
 
     lock_1.acquire()
-    sleep_mock = mocker.patch("filelock._api.time.sleep")
     with pytest.raises(Timeout):
         lock_2.acquire(poll_interval=0.15)
-    sleep_mock.assert_any_call(0.15)
+    steady_clock.assert_any_call(0.15)
     lock_1.release()
 
 
@@ -1969,7 +1974,10 @@ def cancel_after_two() -> bool:
         call_count += 1
         return call_count >= 2
 
-    mocker.patch("filelock._api.time.sleep")
+    mocker.patch(
+        "filelock._api.time",
+        new=SimpleNamespace(perf_counter=time.perf_counter, sleep=mocker.create_autospec(time.sleep)),
+    )
     with pytest.raises(Timeout):
         lock_2.acquire(timeout=10, cancel_check=cancel_after_two)
     assert call_count == 2
@@ -3536,7 +3544,8 @@ def test_lock_descriptor_blocking_retries_until_free(
     assert lock_descriptor(holder, blocking=False) is True
     # Drive the real blocking loop: the first attempt sees contention, the mocked sleep frees the holder, and the
     # second attempt wins. Only the clock is mocked, so a single sleep call proves exactly one retry happened.
-    sleep = mocker.patch("filelock._descriptor.time.sleep", side_effect=lambda _: unlock_descriptor(holder))
+    sleep: Final = mocker.create_autospec(time.sleep, side_effect=lambda _: unlock_descriptor(holder))
+    mocker.patch("filelock._descriptor.time", new=SimpleNamespace(sleep=sleep))
     try:
         assert lock_descriptor(fd, blocking=True, poll_interval=poll_interval) is True
         sleep.assert_called_once_with(poll_interval)

tests/test_marker_records.py

@@ -5,6 +5,7 @@
 import time
 from contextlib import suppress
 from multiprocessing import get_context
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Final
 
 import pytest
@@ -166,7 +167,15 @@ def test_lease_never_ages_out_an_unknown_contract(tmp_path: Path) -> None:
 @NEEDS_STALE_RECLAIM
 def test_lease_ages_out_a_malformed_record(tmp_path: Path, mocker: MockerFixture) -> None:
     # The self-heal still applies to a record that states no contract at all, so corruption cannot wedge contenders.
-    mocker.patch("filelock._soft.time.monotonic", side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD))
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(
+            monotonic=mocker.create_autospec(
+                time.monotonic, side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD)
+            ),
+            sleep=time.sleep,
+        ),
+    )
     marker = tmp_path / "a.lock"
     marker.write_text("filelock/2\nnot-a-record\n", encoding="utf-8")
 
@@ -286,7 +295,15 @@ def test_marker_lock_reclaims_dead_owner_before_its_process_is_closed(marker: Pa
 )
 @NEEDS_STALE_RECLAIM
 def test_marker_lock_reclaims_malformed_record(marker: Path, record: str, mocker: MockerFixture) -> None:
-    mocker.patch("filelock._soft.time.monotonic", side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD))
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(
+            monotonic=mocker.create_autospec(
+                time.monotonic, side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD)
+            ),
+            sleep=time.sleep,
+        ),
+    )
     marker.write_text(record, encoding="utf-8")
     lock = MarkerSoftFileLock(marker)
     _acquire_after_reclaim(lock)

tests/test_read_write_unit.py

@@ -9,6 +9,7 @@
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import ExitStack, closing
 from functools import partial
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Final, Literal
 
 import pytest
@@ -679,7 +680,12 @@ def test_busy_timeout_recomputed_after_journal_mode(
     lock_file: str, mocker: MockerFixture, mode: Literal["read", "write"]
 ) -> None:
     counter = iter([0.0, 0.0, 0.0, 0.5])
-    mocker.patch("filelock._read_write.time.perf_counter", side_effect=counter)
+    mocker.patch(
+        "filelock._read_write.time",
+        new=SimpleNamespace(
+            monotonic=time.monotonic, perf_counter=mocker.create_autospec(time.perf_counter, side_effect=counter)
+        ),
+    )
     lock = ReadWriteLock(lock_file, is_singleton=False)
     (lock.acquire_read if mode == "read" else lock.acquire_write)(timeout=2.0)
     lock.release()

tests/test_soft_lease.py

@@ -701,7 +701,13 @@ def test_lease_supersedes_a_live_holder_once_its_claim_ages_out(marker: Path, mo
     # lease_duration without a refresh. Windows cannot delete a live holder's open marker, so drive the age branch with
     # a non-stale owner and a clock that steps a full duration per look rather than a real second process.
     mocker.patch("filelock._lease.owner_is_stale", return_value=False)
-    mocker.patch("filelock._soft.time.monotonic", side_effect=itertools.count(step=_DURATION))
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(
+            monotonic=mocker.create_autospec(time.monotonic, side_effect=itertools.count(step=_DURATION)),
+            sleep=time.sleep,
+        ),
+    )
     marker.write_text(
         f"filelock/2\npid={os.getpid()}\nhost={host_name()}\nmode=lease\ntoken=stalled\nduration={_DURATION!r}\n",
         encoding="utf-8",
@@ -839,7 +845,13 @@ def test_native_lock_rejects_a_lease_duration(marker: Path) -> None:
 def test_lease_does_not_age_out_a_live_exclusive_owner(marker: Path, mocker: MockerFixture) -> None:
     # An exclusive owner never agreed to expire, so only proof of death may reclaim it, however long it sits unchanged.
     mocker.patch("filelock._lease.owner_is_stale", return_value=False)
-    mocker.patch("filelock._soft.time.monotonic", side_effect=itertools.count(step=_DURATION))
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(
+            monotonic=mocker.create_autospec(time.monotonic, side_effect=itertools.count(step=_DURATION)),
+            sleep=time.sleep,
+        ),
+    )
     marker.write_text(f"filelock/2\npid={os.getpid()}\nhost={socket.gethostname()}\nmode=exclusive\n", encoding="utf-8")
 
     with pytest.raises(Timeout):

tests/test_soft_stale.py

@@ -11,6 +11,7 @@
 from errno import EACCES, EINTR, EINVAL, EIO, ENODEV, ENOSPC, EPERM
 from multiprocessing import get_context
 from pathlib import Path
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Final
 
 import pytest
@@ -1822,7 +1823,10 @@ def test_soft_windows_unlink_gives_up_after_every_attempt_is_denied(tmp_path: Pa
     marker = tmp_path / "a"
     marker.write_text("x", encoding="utf-8")
     lock = SoftFileLock(marker)
-    mocker.patch("filelock._soft.time.sleep")
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(monotonic=time.monotonic, sleep=mocker.create_autospec(time.sleep)),
+    )
     unlink: Final = mocker.patch("filelock._soft.unlink_path", side_effect=PermissionError(EACCES, "handle still open"))
 
     lock._windows_unlink_if_ours(_file_identity(os.lstat(marker)))
@@ -1838,7 +1842,15 @@ def test_soft_windows_unlink_gives_up_after_every_attempt_is_denied(tmp_path: Pa
 def unchanged_past_grace(mocker: MockerFixture) -> None:
     # Each look at the marker lands a full grace window after the previous one on the observer's clock, so an unchanged
     # malformed marker ages out on the second look without the test sleeping through the window.
-    mocker.patch("filelock._soft.time.monotonic", side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD))
+    mocker.patch(
+        "filelock._soft.time",
+        new=SimpleNamespace(
+            monotonic=mocker.create_autospec(
+                time.monotonic, side_effect=itertools.count(step=MALFORMED_LOCK_AGE_THRESHOLD)
+            ),
+            sleep=time.sleep,
+        ),
+    )
 
 
 def test_unparseable_lock_with_an_ancient_mtime_not_evicted_on_first_sight(lock_path: Path) -> None: