prepare for 3.14

Author: mikeshardmind

src/async_utils/__init__.py

@@ -9,7 +9,7 @@
 __author__ = "Michael Hall"
 __license__ = "Apache-2.0"
 __copyright__ = "Copyright 2020-Present Michael Hall"
-__version__ = "2025.07.15b"
+__version__ = "2025.08.03b"
 
 import os
 import sys
@@ -19,8 +19,8 @@
 # - Check use of concurrent.futures.Future before extending this version.
 # - update `_misc._ensure_annotations.py` before extending this version.
 # - ensure `task_cache.__WrappedSignature` still works
-if (_vi.major, _vi.minor) > (3, 13):
-    msg: str = """This library is not tested for use on python versions above 3.13
+if (_vi.major, _vi.minor) > (3, 14):
+    msg: str = """This library is not tested for use on python versions above 3.14
     This library relies on a few internal details that are not safe to rely upon
     without checking this consistently.
     """

src/async_utils/_qs.py

@@ -12,22 +12,19 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-# With thanks to everyone I've ever discussed concurrency or datastructures with
-
 from __future__ import annotations
 
 import asyncio
+import sys
 import threading
 from collections import deque
 from collections.abc import Generator
-
-# PYUPDATE: 3.14 release + 3.14 minimum: reaudit
-# heapq methods are not threadsafe pre 3.14
-# see: GH: cpython 135036
 from heapq import heappop, heappush
 
 from . import _typings as t
 
+THREAD_SAFE_HEAPQ = sys.version_info[:2] >= (3, 14)
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
     import typing
@@ -604,30 +601,43 @@ def _get(self, /) -> T:
 class PriorityQueue[T: HeapqOrderable](BaseQueue[T]):
     """A thread-safe queue with both sync and async access methods."""
 
-    __slots__ = ("_data", "_lock")
+    __slots__ = ("_data",) if THREAD_SAFE_HEAPQ else ("_data", "_lock")
 
     def __init_subclass__(cls) -> t.Never:
         msg = "Don't subclass this"
         raise RuntimeError(msg)
 
     __final__ = True
 
-    def __init__(self, /, maxsize: int | None = None) -> None:
-        super().__init__(maxsize)
-        self._data: list[T] = []
-        # heapq not threadsafe till 3.14
-        self._lock = threading.RLock()
+    if THREAD_SAFE_HEAPQ:
+
+        def __init__(self, /, maxsize: int | None = None) -> None:
+            super().__init__(maxsize)
+            self._data: list[T] = []
+
+        def _put(self, item: T, /) -> None:
+            heappush(self._data, item)
+
+        def _get(self, /) -> T:
+            return heappop(self._data)
+
+    else:
+
+        def __init__(self, /, maxsize: int | None = None) -> None:
+            super().__init__(maxsize)
+            self._data: list[T] = []
+            self._lock = threading.RLock()
+
+        def _put(self, item: T, /) -> None:
+            with self._lock:
+                heappush(self._data, item)
+
+        def _get(self, /) -> T:
+            with self._lock:
+                return heappop(self._data)
 
     def _qsize(self, /) -> int:
         return len(self._data)
 
     def _items(self, /) -> list[T]:
         return self._data.copy()
-
-    def _put(self, item: T, /) -> None:
-        with self._lock:
-            heappush(self._data, item)
-
-    def _get(self, /) -> T:
-        with self._lock:
-            return heappop(self._data)

src/async_utils/lockout.py

@@ -16,10 +16,6 @@
 
 import asyncio
 import concurrent.futures as cf
-
-# PYUPDATE: 3.14 release + 3.14 minimum: reaudit
-# heapq methods are not threadsafe pre 3.14
-# see: GH: cpython 135036
 import heapq
 import threading
 import time
@@ -93,7 +89,6 @@ async def __aenter__(self) -> None:
             now = time.monotonic()
             # There must not be an async context switch between here
             # and replacing the lockout when lockout is in the future
-            # PYUPDATE: The lock here can be removed at 3.14 minimum
             with self._internal_lock:
                 ts = heapq.heappop(self._lockouts)
                 if (sleep_for := ts - now) > 0:

src/async_utils/lru.py

@@ -21,11 +21,14 @@
 # see: GH: cpython 135036
 import heapq
 import math
+import sys
 import threading
 import time
 
 from . import _typings as t
 
+THREAD_SAFE_HEAPQ = sys.version_info[:2] >= (3, 14)
+
 __all__ = ("LRU", "TTLLRU")
 
 
@@ -260,20 +263,19 @@ def __getitem__(self, key: K, /) -> V:
         now = time.monotonic()
         if now > ts:
             raise KeyError
-        self._cache[key] = ts, val
         return val
 
     def __setitem__(self, key: K, value: V, /) -> None:
         ts = time.monotonic() + self._ttl
         with self._internal_lock:
             heapq.heappush(self._expirations, (ts, key))
-        self._cache[key] = (ts, value)
-        self._remove_some_expired()
-        if len(self._cache) > self._maxsize:
-            try:
-                self._cache.pop(next(iter(self._cache)))
-            except (KeyError, StopIteration):
-                pass
+            self._cache[key] = (ts, value)
+            self._remove_some_expired()
+            if len(self._cache) > self._maxsize:
+                try:
+                    self._cache.pop(next(iter(self._cache)))
+                except (KeyError, StopIteration):
+                    pass
 
     def get[T](self, key: K, default: T, /) -> V | T:
         """Get a value by key or default value.
@@ -309,5 +311,6 @@ def remove(self, key: K, /) -> None:
         key:
             The key to remove.
         """
-        self._remove_some_expired()
-        self._cache.pop(key, None)
+        with self._internal_lock:
+            self._remove_some_expired()
+            self._cache.pop(key, None)

src/async_utils/priority_sem.py

@@ -18,10 +18,6 @@
 import asyncio
 import concurrent.futures as cf
 import contextvars
-
-# PYUPDATE: 3.14 release + 3.14 minimum: reaudit
-# heapq methods are not threadsafe pre 3.14
-# see: GH: cpython 135036
 import heapq
 import threading
 import time
@@ -123,13 +119,9 @@ def __init__(self, value: int = 1) -> None:
             raise ValueError(msg)
         self._waiters: list[_PriorityWaiter] | None = None
         self._value: int = value
-        # PYUPDATE: 3.14 minimum heapq safety
         self._internal_lock: threading.RLock = threading.RLock()
 
     def __locked(self) -> bool:
-        # Must do a comparison based on priority then FIFO
-        # in the case of existing waiters
-        # not guaranteed to be immediately available
         with self._internal_lock:
             return self._value == 0 or (
                 any(not w.cancelled() for w in (self._waiters or ()))

src/async_utils/task_cache.py

@@ -77,7 +77,7 @@ def _chain_fut[R](c_fut: cf.Future[R], a_fut: asyncio.Future[R]) -> None:
 class _WrappedSignature[**P, R]:
     #: PYUPGRADE: Ensure inspect.signature still accepts this
     # as func.__signature__
-    # Known working: py 3.12.0 - py3.14b4 range inclusive
+    # Known working: py 3.12.0 - py3.14rc1 range inclusive
     def __init__(self, f: TaskCoroFunc[P, R], w: TaskFunc[P, R]) -> None:
         self._f: Callable[..., t.Any] = f  # anotation needed for inspect use below....
         self._w = w
@@ -193,7 +193,7 @@ def wrapped(*args: P.args, **kwargs: P.kwargs) -> asyncio.Task[R]:
 
             return a_fut
 
-        # PYUPGRADE: 3.14.0 recheck (last checked 3.14b4), 3.15+
+        # PYUPGRADE: 3.14.0 recheck (last checked 3.14rc1), 3.15+
         wrapped.__signature__ = _WrappedSignature(coro, wrapped)  # type: ignore[attr-defined]
 
         return wrapped