Support python 3.14

.github/workflows/ci.yml

@@ -2,17 +2,20 @@ name: ci
 
 on: [push, pull_request]
 
+env:
+    FORCE_COLOR: 1
+
 jobs:
     pre-commit:
         runs-on: ubuntu-latest
 
         steps:
         -   uses: actions/checkout@v5
 
-        -   name: Set up Python 3.13
+        -   name: Set up Python 3.14
             uses: actions/setup-python@v5
             with:
-                python-version: '3.13'
+                python-version: '3.14'
 
         -   name: Install Python dependencies
             run: pip install -e .[pre-commit]
@@ -25,7 +28,7 @@ jobs:
 
         strategy:
             matrix:
-                python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+                python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
             fail-fast: false
 
         services:
@@ -42,14 +45,18 @@ jobs:
             with:
                 python-version: ${{ matrix.python-version }}
 
-        -   name: Install python dependencies
-            run: pip install .[tests]
+        -   name: Set up uv
+            uses: astral-sh/setup-uv@v7
+            with:
+                python-version: ${{ matrix.python-version }}
+                version: 0.9.4
+                activate-environment: true
 
-        -   name: Run pytest
-            run: pytest -s --cov=plumpy tests/
+        -   name: Install dependencies
+            run: uv sync
 
-        -   name: Create xml coverage
-            run: coverage xml
+        -   name: Run pytest
+            run: pytest --cov=plumpy tests/
 
         -   name: Upload coverage to Codecov
             if: github.repository == 'aiidateam/plumpy'

pyproject.toml

@@ -25,6 +25,7 @@ classifiers = [
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
 ]
 keywords = ['workflow', 'multithreaded', 'rabbitmq']
 requires-python = '>=3.9'
@@ -54,21 +55,19 @@ docs = [
     'myst-nb~=1.2.0',
     'sphinx~=7.2.0',
     'sphinx-book-theme~=1.1.4',
-    'importlib-metadata~=4.12.0',
 ]
 pre-commit = [
     'mypy==1.18.2',
     'pre-commit~=3.6',
     'types-pyyaml~=6.0'
 ]
 tests = [
-    'ipykernel==6.12.1',
+    'ipykernel~=6.31.0',
     'pytest~=8.4',
     'pytest-asyncio~=0.12,<0.17',
-    'pytest-cov~=4.1',
+    'pytest-cov~=7.0',
     'pytest-notebook>=0.8.0',
-    'shortuuid==1.0.8',
-    'importlib-resources~=5.2',
+    'shortuuid==1.0.13',
 ]
 
 [tool.flit.module]
@@ -138,11 +137,16 @@ module = [
 ignore_missing_imports = true
 
 [tool.pytest.ini_options]
-minversion = '6.0'
+addopts = '--strict-config --strict-markers -ra --cov-report xml --cov-append'
+minversion = '7.0'
 testpaths = [
     'test',
 ]
-filterwarnings = []
+filterwarnings = [
+  "ignore:'asyncio.get_event_loop_policy' is deprecated:DeprecationWarning::",
+  "ignore:'asyncio.set_event_loop_policy' is deprecated:DeprecationWarning::",
+  "ignore:'asyncio.DefaultEventLoopPolicy' is deprecated:DeprecationWarning::",
+]
 
 [tool.tox]
 legacy_tox_ini = """
@@ -183,3 +187,6 @@ commands =
         --port 0 --open-browser \
         -n -b {posargs:html} docs/source/ docs/_build/{posargs:html}
 """
+
+[tool.uv.sources]
+nest-asyncio = { git = "https://github.com/danielhollas/nest_asyncio", branch = "python-3.14" }

src/plumpy/communications.py

@@ -7,7 +7,7 @@
 
 import kiwipy
 
-from . import futures
+from . import events, futures
 from .utils import ensure_coroutine
 
 __all__ = [
@@ -124,7 +124,7 @@ def wrap_communicator(
     return LoopCommunicator(communicator, loop)
 
 
-class LoopCommunicator(kiwipy.Communicator):  # type: ignore
+class LoopCommunicator(kiwipy.Communicator):  # type: ignore[misc]
     """Wrapper around a `kiwipy.Communicator` that schedules any subscriber messages on a given event loop."""
 
     def __init__(self, communicator: kiwipy.Communicator, loop: Optional[asyncio.AbstractEventLoop] = None):
@@ -136,7 +136,13 @@ def __init__(self, communicator: kiwipy.Communicator, loop: Optional[asyncio.Abs
         assert communicator is not None
 
         self._communicator = communicator
-        self._loop: asyncio.AbstractEventLoop = loop or asyncio.get_event_loop()
+        if loop:
+            self._loop = loop
+        else:
+            try:
+                self._loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self._loop = events.create_running_loop()
 
     def loop(self) -> asyncio.AbstractEventLoop:
         return self._loop

src/plumpy/events.py

@@ -21,6 +21,13 @@
 get_event_loop = asyncio.get_event_loop
 
 
+def create_running_loop() -> asyncio.AbstractEventLoop:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    return loop
+
+
 def set_event_loop(*args: Any, **kwargs: Any) -> None:
     raise NotImplementedError('this method is not implemented because `plumpy` uses a single reentrant loop')
 
@@ -29,21 +36,23 @@ def new_event_loop(*args: Any, **kwargs: Any) -> asyncio.AbstractEventLoop:
     raise NotImplementedError('this method is not implemented because `plumpy` uses a single reentrant loop')
 
 
-class PlumpyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
+class PlumpyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):  # type: ignore[name-defined,misc]
     """Custom event policy that always returns the same event loop that is made reentrant by ``nest_asyncio``."""
 
     _loop: Optional[asyncio.AbstractEventLoop] = None
 
-    def get_event_loop(self) -> asyncio.AbstractEventLoop:
-        """Return the patched event loop."""
+    def new_event_loop(self) -> asyncio.AbstractEventLoop:
         import nest_asyncio
 
-        if self._loop is None:
-            self._loop = super().get_event_loop()
-            nest_asyncio.apply(self._loop)
+        self._loop = super().new_event_loop()
+        nest_asyncio.apply(self._loop)
 
         return self._loop
 
+    def get_event_loop(self) -> asyncio.AbstractEventLoop:
+        """Return the patched event loop."""
+        return self._loop or self.new_event_loop()
+
 
 def set_event_loop_policy() -> None:
     """Enable plumpy's event loop policy that will make event loop's reentrant."""
@@ -55,18 +64,23 @@ def set_event_loop_policy() -> None:
 
 def reset_event_loop_policy() -> None:
     """Reset the event loop policy to the default."""
-    loop = get_event_loop()
-
-    cls = loop.__class__
 
-    del cls._check_running  # type: ignore
-    del cls._nest_patched  # type: ignore
+    try:
+        # TODO: I think we should not be calling get_event_loop
+        # but maybe get_running_loop?
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        pass
+    else:
+        cls = loop.__class__
+        del cls._check_running  # type: ignore
+        del cls._nest_patched  # type: ignore
 
     asyncio.set_event_loop_policy(None)
 
 
 def run_until_complete(future: asyncio.Future, loop: Optional[asyncio.AbstractEventLoop] = None) -> Any:
-    loop = loop or get_event_loop()
+    loop = loop or asyncio.get_event_loop()
     return loop.run_until_complete(future)
 
 

src/plumpy/futures.py

@@ -8,6 +8,8 @@
 
 import kiwipy
 
+from . import events
+
 __all__ = ['CancelledError', 'Future', 'chain', 'copy_future', 'create_task', 'gather']
 
 CancelledError = kiwipy.CancelledError
@@ -65,7 +67,11 @@ def create_task(coro: Callable[[], Awaitable[Any]], loop: Optional[asyncio.Abstr
     :return: the future representing the outcome of the coroutine
 
     """
-    loop = loop or asyncio.get_event_loop()
+    if not loop:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = events.create_running_loop()
 
     future = loop.create_future()
 

src/plumpy/processes.py

@@ -286,7 +286,13 @@ def __init__(
         # Don't allow the spec to be changed anymore
         self.spec().seal()
 
-        self._loop = loop if loop is not None else asyncio.get_event_loop()
+        if loop:
+            self._loop = loop
+        else:
+            try:
+                self._loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self._loop = events.create_running_loop()
 
         self._setup_event_hooks()
 

src/plumpy/utils.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import asyncio
 import functools
 import importlib
 import inspect
@@ -195,10 +194,10 @@ def ensure_coroutine(coro_or_fn: Any) -> Callable[..., Awaitable[Any]]:
     :param fct: the function
     :returns: the coroutine
     """
-    if asyncio.iscoroutinefunction(coro_or_fn):
+    if inspect.iscoroutinefunction(coro_or_fn):
         return coro_or_fn
 
-    if asyncio.iscoroutinefunction(coro_or_fn.__call__):
+    if inspect.iscoroutinefunction(coro_or_fn.__call__):
         return coro_or_fn
 
     if callable(coro_or_fn):

tests/notebooks/get_event_loop.ipynb

@@ -7,11 +7,13 @@
    "outputs": [],
    "source": [
     "import asyncio\n",
+    "import warnings\n",
     "\n",
     "from plumpy import PlumpyEventLoopPolicy, set_event_loop_policy\n",
     "\n",
-    "set_event_loop_policy()\n",
-    "assert isinstance(asyncio.get_event_loop_policy(), PlumpyEventLoopPolicy)\n",
+    "with warnings.catch_warnings(record=True):\n",
+    "    set_event_loop_policy()\n",
+    "    assert isinstance(asyncio.get_event_loop_policy(), PlumpyEventLoopPolicy)\n",
     "assert hasattr(asyncio.get_event_loop(), '_nest_patched')"
    ]
   }

tests/test_communications.py

@@ -36,7 +36,6 @@ def subscriber():
     """Return an instance of `Subscriber`."""
     return Subscriber()
 
-
 def test_add_rpc_subscriber(loop_communicator, subscriber):
     """Test the `LoopCommunicator.add_rpc_subscriber` method."""
     assert loop_communicator.add_rpc_subscriber(subscriber) is not None