Prep 2.0.0

.github/workflows/unittests.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [ "3.7", "3.8", "3.9", "3.10", "3.11", "3.12" ]
+        python-version: [ "3.10", "3.11", "3.12", "3.13" ]
 
     steps:
       - uses: actions/checkout@v3
@@ -27,9 +27,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install flake8 pytest
-          pip install -r requirements-tests.txt
-          pip install .
+          pip install .[anyio,tests]
       - name: Lint with flake8
         run: |
           # stop the build if there are Python syntax errors or undefined names

README.md

@@ -15,12 +15,18 @@ because [python decided not to support RLock in asyncio](https://discuss.python.
 their [argument](https://discuss.python.org/t/asyncio-rlock-reentrant-locks-for-async-python/21509/2) being that every
 extra bit of functionality adds to maintenance cost.
 
-Install with
+Install normally for asyncio support:
 
 ```bash
-pip install fair-async-rlock
+
 ```
 
+or with AnyIO support:
+
+```bash
+pip install fair-async-rlock[anyio]
+````
+
 ## About Fair Reentrant Lock for AsyncIO
 
 A reentrant lock (or recursive lock) is a particular type of lock that can be "locked" multiple times by the same task
@@ -111,4 +117,5 @@ with `asyncio.Lock`.
 ### Change Log
 
 27 Jan, 2024 - 1.0.7 released. Fixed a bug that allowed another task to get the lock before a waiter got its turn on the
-event loop.
+event loop.
+17 Mar, 2025 - 2.0.0 released. Remove support for < 3.10.

pyproject.toml

@@ -1,6 +1,29 @@
+# pyproject.toml
+
 [build-system]
-requires = [
-    "setuptools>=42",
-    "wheel"
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fair_async_rlock"
+version = "2.0.0"
+description = "A fair async RLock for Python"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache Software License" }
+authors = [{ name = "Joshua G. Albert", email = "[email protected]" }]
+keywords = ["async", "fair", "reentrant", "lock", "concurrency"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent"
 ]
-build-backend = "setuptools.build_meta"
+urls = { "Homepage" = "https://github.com/joshuaalbert/FairAsyncRLock" }
+dynamic = ["dependencies", "optional-dependencies"]
+
+[tool.setuptools]
+include-package-data = true
+
+
+[tool.setuptools.packages.find]
+where = ["src"]

requirements-anyio.txt

@@ -0,0 +1 @@
+anyio>=4.5

requirements-tests.txt

@@ -1,2 +1,5 @@
-pytest<8.0.0
-pytest-asyncio
+flake8
+pytest
+pytest-asyncio
+trio==0.25.*
+anyio>=4.5

setup.py

@@ -1,31 +1,19 @@
 #!/usr/bin/env python
 
-from setuptools import find_packages
 from setuptools import setup
 
-with open("README.md", "r") as fh:
-    long_description = fh.read()
+install_requires = []
 
-setup(name='fair_async_rlock',
-      version='1.0.7',
-      description='A well-tested implementation of a fair asynchronous RLock for concurrent programming.',
-      long_description=long_description,
-      long_description_content_type="text/markdown",
-      url="https://github.com/Joshuaalbert/FairAsyncRLock",
-      author='Joshua G. Albert',
-      author_email='[email protected]',
-      setup_requires=[],
-      install_requires=[],
-      tests_require=[
-          'pytest',
-          'pytest-asyncio'
-      ],
-      package_dir={'': './'},
-      packages=find_packages('./'),
-      classifiers=[
-          "Programming Language :: Python :: 3",
-          "License :: OSI Approved :: Apache Software License",
-          "Operating System :: OS Independent",
-      ],
-      python_requires='>=3.7',
-      )
+
+def load_requirements(file_name):
+    with open(file_name, "r") as file:
+        return [line.strip() for line in file if line.strip() and not line.startswith("#")]
+
+
+setup(
+    install_requires=load_requirements("requirements.txt"),
+    extras_require={
+        "tests": load_requirements("requirements-tests.txt"),
+        'anyio': load_requirements("requirements-anyio.txt")
+    }
+)

src/fair_async_rlock/__init__.py

@@ -0,0 +1,6 @@
+from fair_async_rlock.asyncio_fair_async_rlock import *
+
+try:
+    from fair_async_rlock.anyio_fair_async_rlock import *
+except ImportError:
+    pass

src/fair_async_rlock/anyio_fair_async_rlock.py

@@ -0,0 +1,29 @@
+from typing import TypeVar
+
+import anyio
+
+from fair_async_rlock.base_fair_async_rlock import BaseFairAsyncRLock
+
+__all__ = [
+    'AnyIOFairAsyncRLock'
+]
+TaskType = TypeVar('TaskType')
+EventType = TypeVar('EventType')
+
+
+class AnyIOFairAsyncRLock(BaseFairAsyncRLock[anyio.TaskInfo, anyio.Event]):
+    """
+    A fair reentrant lock for async programming. Fair means that it respects the order of acquisition.
+    """
+
+    def _get_current_task(self) -> anyio.TaskInfo:
+        return anyio.get_current_task()
+
+    def _get_cancelled_exc_class(self) -> type[BaseException]:
+        return anyio.get_cancelled_exc_class()
+
+    def _get_wake_event(self) -> anyio.Event:
+        return anyio.Event()
+
+    async def _checkpoint(self) -> None:
+        await anyio.lowlevel.checkpoint()

src/fair_async_rlock/asyncio_fair_async_rlock.py

@@ -0,0 +1,28 @@
+import asyncio
+from typing import Any, TypeVar
+
+from fair_async_rlock.base_fair_async_rlock import BaseFairAsyncRLock
+
+__all__ = [
+    'FairAsyncRLock'
+]
+TaskType = TypeVar('TaskType')
+EventType = TypeVar('EventType')
+
+
+class FairAsyncRLock(BaseFairAsyncRLock[asyncio.Task[Any], asyncio.Event]):
+    """
+    A fair reentrant lock for async programming. Fair means that it respects the order of acquisition.
+    """
+
+    def _get_current_task(self) -> asyncio.Task[Any] | None:
+        return asyncio.current_task()
+
+    def _get_cancelled_exc_class(self) -> type[BaseException]:
+        return asyncio.CancelledError
+
+    def _get_wake_event(self) -> asyncio.Event:
+        return asyncio.Event()
+
+    async def _checkpoint(self) -> None:
+        await asyncio.sleep(0)

fair_async_rlock/fair_async_rlock.py → src/fair_async_rlock/base_fair_async_rlock.py

@@ -1,47 +1,85 @@
-import asyncio
+from abc import ABC, abstractmethod
 from collections import deque
 
-__all__ = [
-    'FairAsyncRLock'
-]
+from typing import Any, Generic, TypeVar, Protocol
 
+class _Event(Protocol):
+    def set(self) -> None: ...
+    async def wait(self) -> Any: ...
 
-class FairAsyncRLock:
+
+TaskType = TypeVar("TaskType")
+EventType = TypeVar("EventType", bound=_Event)
+
+
+class AbstractFairAsyncRLock(ABC, Generic[TaskType, EventType]):
+    @abstractmethod
+    def _get_current_task(self) -> TaskType | None:
+        ...
+
+    @abstractmethod
+    def _get_cancelled_exc_class(self) -> type[BaseException]:
+        ...
+
+    @abstractmethod
+    def _get_wake_event(self) -> EventType:
+        ...
+
+    @abstractmethod
+    async def _checkpoint(self) -> None:
+        ...
+
+
+class BaseFairAsyncRLock(AbstractFairAsyncRLock[TaskType, EventType]):
     """
     A fair reentrant lock for async programming. Fair means that it respects the order of acquisition.
     """
 
     def __init__(self):
-        self._owner: asyncio.Task | None = None
-        self._count = 0
-        self._owner_transfer = False
-        self._queue = deque()
+        self._owner: TaskType | None = None
+        self._count: int = 0
+        self._owner_transfer: bool = False
+        self._queue: deque[EventType] = deque()
 
-    def is_owner(self, task=None):
+    def is_owner(self, task: TaskType | None = None) -> bool:
         if task is None:
-            task = asyncio.current_task()
+            task = self._get_current_task()
         return self._owner == task
 
     def locked(self) -> bool:
         return self._owner is not None
 
-    async def acquire(self):
+    async def acquire(self) -> None:
         """Acquire the lock."""
-        me = asyncio.current_task()
+        me = self._get_current_task()
 
         # If the lock is reentrant, acquire it immediately
         if self.is_owner(task=me):
             self._count += 1
+            try:
+                await self._checkpoint()
+            except self._get_cancelled_exc_class():
+                # Cancelled, while reentrant, so release the lock
+                self._owner_transfer = False
+                self._owner = me
+                self._count = 1
+                self._current_task_release()
+                raise
             return
 
         # If the lock is free (and ownership not in midst of transfer), acquire it immediately
         if self._count == 0 and not self._owner_transfer:
             self._owner = me
             self._count = 1
+            try:
+                await self._checkpoint()
+            except self._get_cancelled_exc_class():
+                self._current_task_release()
+                raise
             return
 
         # Create an event for this task, to notify when it's ready for acquire
-        event = asyncio.Event()
+        event = self._get_wake_event()
         self._queue.append(event)
 
         # Wait for the lock to be free, then acquire
@@ -50,17 +88,18 @@ async def acquire(self):
             self._owner_transfer = False
             self._owner = me
             self._count = 1
-        except asyncio.CancelledError:
+        except self._get_cancelled_exc_class():
             try:  # if in queue, then cancelled before release
                 self._queue.remove(event)
-            except ValueError:  # otherwise, release happened, this was next, and we simulate passing on
+            except ValueError:
+                # otherwise, release happened, this was next, and we simulate passing on
                 self._owner_transfer = False
                 self._owner = me
                 self._count = 1
                 self._current_task_release()
             raise
 
-    def _current_task_release(self):
+    def _current_task_release(self) -> None:
         self._count -= 1
         if self._count == 0:
             self._owner = None
@@ -73,7 +112,7 @@ def _current_task_release(self):
 
     def release(self):
         """Release the lock"""
-        me = asyncio.current_task()
+        me = self._get_current_task()
 
         if self._owner is None:
             raise RuntimeError(f"Cannot release un-acquired lock. {me} tried to release.")