Deprecate nest asyncio

.github/workflows/cd.yml

@@ -58,7 +58,7 @@ jobs:
 
         strategy:
             matrix:
-                python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+                python-version: ['3.10', '3.11', '3.12']
 
         services:
             postgres:

.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
 
         strategy:
             matrix:
-                python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+                python-version: ['3.10', '3.11', '3.12']
             fail-fast: false
 
         services:

docs/source/concepts.md

@@ -32,7 +32,7 @@ WorkChains support the use of logical constructs such as `If_` and `While_` to c
 
 A `Controller` can control processes throughout their lifetime, by sending and receiving messages. It can launch, pause, continue, kill and check status of the process.
 
-The {py:class}`~plumpy.process_comms.RemoteProcessThreadController` can communicate with the process over the thread communicator provided by {{kiwipy}} which can subscribe and send messages over the {{rabbitmq}} message broker.
+The {py:class}`~plumpy.rmq.process_control.RemoteProcessThreadController` can communicate with the process over the thread communicator provided by {{kiwipy}} which can subscribe and send messages over the {{rabbitmq}} message broker.
 
 The thread communicator runs on a independent thread (event loop) and so will not be blocked by sometimes long waiting times in the process event loop.
 Using RabbitMQ means that  even if the computer is terminated unexpectedly, messages are persisted and can be run once the computer restarts.

docs/source/conf.py

@@ -47,7 +47,7 @@
 pygments_style = None
 
 intersphinx_mapping = {
-    'python': ('https://docs.python.org/3.8', None),
+    'python': ('https://docs.python.org/3.10', None),
     'kiwipy': ('https://kiwipy.readthedocs.io/en/latest/', None),
 }
 

docs/source/nitpick-exceptions

@@ -18,12 +18,12 @@ py:class kiwipy.communications.Communicator
 
 # unavailable forward references
 py:class plumpy.process_states.Command
-py:class plumpy.process_states.State
+py:class plumpy.state_machine.State
 py:class plumpy.base.state_machine.State
 py:class State
 py:class Process
 py:class plumpy.futures.CancellableAction
-py:class plumpy.communications.LoopCommunicator
+py:class plumpy.rmq.communications.LoopCommunicator
 py:class plumpy.persistence.PersistedPickle
 py:class plumpy.utils.AttributesFrozendict
 py:class plumpy.workchains._FunctionCall

docs/source/tutorial.ipynb

@@ -66,7 +66,7 @@
     "The {py:class}`~plumpy.workchains.WorkChain`\n",
     ": A subclass of `Process` that allows for running a process as a set of discrete steps (also known as instructions), with the ability to save the state of the process after each instruction has completed.\n",
     "\n",
-    "The process `Controller` (principally the {py:class}`~plumpy.process_comms.RemoteProcessThreadController`)\n",
+    "The process `Controller` (principally the {py:class}`~plumpy.rmq.process_control.RemoteProcessThreadController`)\n",
     ": To control the process or workchain throughout its lifetime."
    ]
   },

pyproject.toml

@@ -20,18 +20,18 @@ classifiers = [
     'License :: OSI Approved :: MIT License',
     'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
     'Programming Language :: Python',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
 ]
 keywords = ['workflow', 'multithreaded', 'rabbitmq']
-requires-python = '>=3.8'
+requires-python = '>=3.10'
 dependencies = [
     'kiwipy[rmq]~=0.8.5',
+    'msgpack~=1.1',
     'nest_asyncio~=1.5,>=1.5.1',
     'pyyaml~=6.0',
+    'typing-extensions~=4.12'
 ]
 
 [project.urls]
@@ -57,8 +57,8 @@ pre-commit = [
 ]
 tests = [
     'ipykernel==6.12.1',
-    'pytest~=7.0',
-    'pytest-asyncio~=0.12,<0.17',
+    'pytest~=8.0',
+    'pytest-asyncio~=0.25',
     'pytest-cov~=4.1',
     'pytest-notebook>=0.8.0',
     'shortuuid==1.0.8',
@@ -132,6 +132,7 @@ module = [
     'aiocontextvars.*',
     'frozendict.*',
     'kiwipy.*',
+    'msgpack.*',
     'nest_asyncio.*',
     'tblib.*',
 ]
@@ -162,6 +163,7 @@ testpaths = [
     'test',
 ]
 filterwarnings = []
+asyncio_default_fixture_loop_scope = "function"
 
 [tool.yapf]
 align_closing_bracket_with_visual_indent = true

src/plumpy/__init__.py

@@ -1,39 +1,143 @@
 # -*- coding: utf-8 -*-
-# mypy: disable-error-code=name-defined
 __version__ = '0.24.0'
 
 import logging
 
-from .communications import *
-from .events import *
-from .exceptions import *
-from .futures import *
-from .loaders import *
-from .mixins import *
-from .persistence import *
-from .ports import *
-from .process_comms import *
-from .process_listener import *
-from .process_states import *
-from .processes import *
-from .utils import *
-from .workchains import *
+from .base.state_machine import TransitionFailed
+
+# interfaces
+from .controller import ProcessController
+from .coordinator import Coordinator
+from .events import (
+    PlumpyEventLoopPolicy,
+    get_event_loop,
+    new_event_loop,
+    reset_event_loop_policy,
+    run_until_complete,
+    set_event_loop,
+    set_event_loop_policy,
+)
+from .exceptions import (
+    ClosedError,
+    CoordinatorConnectionError,
+    CoordinatorTimeoutError,
+    InvalidStateError,
+    KilledError,
+    PersistenceError,
+    UnsuccessfulResult,
+)
+from .futures import CancellableAction, Future, capture_exceptions, create_task
+from .loaders import DefaultObjectLoader, ObjectLoader, get_object_loader, set_object_loader
+from .message import Message, MsgContinue, MsgCreate, MsgKill, MsgLaunch, MsgPause, MsgPlay, MsgStatus, ProcessLauncher
+from .persistence import (
+    Bundle,
+    InMemoryPersister,
+    LoadSaveContext,
+    PersistedCheckpoint,
+    Persister,
+    PicklePersister,
+    Savable,
+    SavableFuture,
+    auto_persist,
+)
+from .ports import UNSPECIFIED, InputPort, OutputPort, Port, PortNamespace, PortValidationError
+from .process_listener import ProcessListener
+from .process_spec import ProcessSpec
+from .process_states import (
+    Continue,
+    Created,
+    Excepted,
+    Finished,
+    Interruption,
+    Kill,
+    Killed,
+    KillInterruption,
+    PauseInterruption,
+    ProcessState,
+    Running,
+    Stop,
+    Wait,
+    Waiting,
+)
+from .processes import BundleKeys, Process
+from .utils import AttributesDict
+from .workchains import ToContext, WorkChain, WorkChainSpec, if_, return_, while_
 
 __all__ = (
-    events.__all__
-    + exceptions.__all__
-    + processes.__all__
-    + utils.__all__
-    + futures.__all__
-    + mixins.__all__
-    + persistence.__all__
-    + communications.__all__
-    + process_comms.__all__
-    + process_listener.__all__
-    + workchains.__all__
-    + loaders.__all__
-    + ports.__all__
-    + process_states.__all__
+    'UNSPECIFIED',
+    'AttributesDict',
+    'Bundle',
+    'BundleKeys',
+    'CancellableAction',
+    'ClosedError',
+    'Continue',
+    'Coordinator',
+    'CoordinatorConnectionError',
+    'CoordinatorTimeoutError',
+    'Created',
+    'DefaultObjectLoader',
+    'Excepted',
+    'Finished',
+    'Future',
+    'InMemoryPersister',
+    'InputPort',
+    'Interruption',
+    'InvalidStateError',
+    'Kill',
+    'KillInterruption',
+    'Killed',
+    'KilledError',
+    'LoadSaveContext',
+    'Message',
+    'MsgContinue',
+    'MsgCreate',
+    'MsgKill',
+    'MsgLaunch',
+    'MsgPause',
+    'MsgPlay',
+    'MsgStatus',
+    'ObjectLoader',
+    'OutputPort',
+    'PauseInterruption',
+    'PersistedCheckpoint',
+    'PersistenceError',
+    'Persister',
+    'PicklePersister',
+    'PlumpyEventLoopPolicy',
+    'Port',
+    'PortNamespace',
+    'PortValidationError',
+    'Process',
+    'ProcessController',
+    'ProcessLauncher',
+    'ProcessListener',
+    'ProcessSpec',
+    'ProcessState',
+    'Running',
+    'Savable',
+    'SavableFuture',
+    'Stop',
+    'ToContext',
+    'TransitionFailed',
+    'UnsuccessfulResult',
+    'Wait',
+    'Waiting',
+    'WorkChain',
+    'WorkChainSpec',
+    'auto_persist',
+    'capture_exceptions',
+    'create_task',
+    'get_event_loop',
+    'get_object_loader',
+    'if_',
+    'new_event_loop',
+    'reset_event_loop_policy',
+    'return_',
+    'run_until_complete',
+    'set_event_loop',
+    'set_event_loop_policy',
+    'set_object_loader',
+    'while_',
 )