frequenz-floss-frequenz-sdk-python-1166

examples
mkdocs.yml
noxfile.py
pyproject.toml
src
tests

async def run(*actors: Actor) -> None:
    """Await the completion of all actors.

    !!! info

        Please read the [`actor` module documentation][frequenz.sdk.actor] for more
        comprehensive guide on how to use and implement actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done
    pending_tas
…[571 chars omitted]…
ame())
            elif exception := task.exception():
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=exception,
                )
            else:
                _logger.info("Actor %s: Finished normally.", task.get_name())

    _logger.info("All %s actor(s) finished.", len(actors))

_logger = logging.getLogger(__name__)


class Actor(BackgroundService, abc.ABC):
    """A primitive unit of computation that runs autonomously.

    To implement an actor, subclasses must implement the
    [`_run()`][frequenz.sdk.actor--the-_run-method] method, which should run the actor's
    logic. The [`_run()`][frequenz.sdk.actor--the-_run-method] method is called by the
    base class when the actor is started, and is expected to run until the actor is
    stopped.

    !!! info

        Please read the [`actor` module documentation][frequenz.sdk.actor] for more
        comprehensive guide on how to use and implement actors properly.
    """

    RESTART_
…[3144 chars omitted]…
ailing out...",
                    self,
                    limit_str,
                )
                raise
            except BaseException:  # pylint: disable=broad-except
                _logger.exception("Actor %s: Raised a BaseException.", self)
                raise
            break

        _logger.info("Actor %s: Stopped.", self)
__init__.py
_actor.py
_background_service.py
_run_utils.py

class BackgroundService(abc.ABC):
    """A background service that can be started and stopped.

    A background service is a service that runs in the background spawning one or more
    tasks. The service can be [started][frequenz.sdk.actor.BackgroundService.start]
    and [stopped][frequenz.sdk.actor.BackgroundService.stop] and can work as an
    async context manager to provide deterministic cleanup.

    To implement a background service, subclasses must implement the
    [`start()`][frequenz.sdk.actor.BackgroundService.start] method, which should
    start the background tasks needed by the service, and add them to the `_tasks`
    protected attribute.

    If 
…[8629 chars omitted]…
log.record_tuples == [
        (*RUN_INFO, "Starting 1 actor(s)..."),
        (*RUN_INFO, "Actor EchoActor[EchoActor]: Starting..."),
        (*ACTOR_INFO, "Actor EchoActor[EchoActor]: Started."),
        (*ACTOR_INFO, "Actor EchoActor[EchoActor]: Cancelled."),
        (*RUN_ERROR, "Actor EchoActor[EchoActor]: Raised an exception while running."),
        (*RUN_INFO, "All 1 actor(s) finished."),
    ]

    def __init__(self, *, name: str | None = None) -> None:
        """Initialize this BackgroundService.

        Args:
            name: The name of this background service. If `None`, `str(id(self))` will
                be used. This is used mostly for debugging purposes.
        """
        self._name: str = str(id(self)) if name is None else name
        self._tasks: set[asyncio.Task[Any]] = set()

    @abc.abstractmethod
    def start(self) -> None:
        """Sta
…[2191 chars omitted]…
ed all the
            # tasks.
            _, rest = exc_group.split(asyncio.CancelledError)
            if rest is not None:
                # We are filtering out from an exception group, we really don't want to
                # add the exceptions we just filtered by adding a from clause here.
                raise rest  # pylint: disable=raise-missing-from

    async def __aenter__(self) -> Self:

        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> None:
        """Exit an async context.

        Stop this background service.

        Args:
            exc_type: The type of the exception raised, if any.
            exc_val: The exception raised, if any.
            exc_tb: The traceback of the exception raised, if any.
        """
        await self.stop()

    async def wait(self) -> None:
        """Wait this background service to finish.

        Wait until all background service tasks are finished.

        Raises:
            BaseExcept
…[8301 chars omitted]…
_running is False
    assert BaseTestActor.restart_count == restart_limit
    expected_log = [
        (*RUN_INFO, "Starting 1 actor(s)..."),
        (*RUN_INFO, "Actor RaiseExceptionActor[test]: Starting..."),
        (*ACTOR_INFO, "Actor RaiseExceptionActor[test]: Started."),
    ]
    restart_delay = Actor.RESTART_DELAY.total_seconds()
    for i in range(restart_limit):
        expected_log.extend(

- Add stop method to the FormulaEngine. Now it is possible to stop custom formulas.

- Stop fallback formulas when primary formula starts working again.

## Bug Fixes

- Fixed bug with formulas raising exception when stopped.
5:"""Actors are a primitive unit of computation that runs autonomously.
39:  ([`_run()`][_run] method), the actor will be automatically restarted. This ensures
47:  a [`run()`][frequenz.sdk.actor.run] function is provided to easily run a group of
56:1. By using the [`run()`][frequenz.sdk.actor.run] function.
65:       be held for as long as the actor is expected to be running, otherwise its 
…[2721 chars omitted]…
hat will run the actor.
547:7. We start the `main()` function in the async loop using [`asyncio.run()`][asyncio.run].
553:    [`run()`][frequenz.sdk.actor.run] function.
576:15. The [`_run()`][_run] method will finish normally and the actor will be stopped, so
577:    the [`run()`][frequenz.sdk.actor.run] function will return.
597:[_run]: #the-_run-method
603:from ._run_utils import run
609:    "run",

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[513 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

  /repo/tests/actor/test_actor.py:358: DeprecationWarning: Please use BroadcastChannel instead.
    echo_chan: Broadcast[bool] = Broadcast(name="echo output")

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
=========================== short test summary info ============================
FAILED tests/actor/test_actor.py::test_does_not_restart_if_cancelled - Assert...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 7 passed, 12 warnings in 1.02s

                await run(actor)
    
        assert actor.is_running is False
        assert BaseTestActor.restart_count == 0
>       assert caplog.record_tuples == [
            (*RUN_INFO, "Starting 1 actor(s)..."),
            (*RUN_INFO, "Actor EchoActor[EchoActor]: Starting..."),
            (*ACTOR_INFO, "Actor EchoActor[EchoActor]: Started."),

+    """Split an exception into its cancelled and non-cancelled parts.
+
+    Exception groups are searched recursively, so a `CancelledError` buried inside
+    an exception group is still recognized as a cancellation.
+
+    Args:
+        exception: The exception to inspect.
+
+    Returns:
+        A tuple with two elements: whether the exception represents a cancellation,
+        and the part of the exception that is not a cancellation (`None` if the
+       
…[1123 chars omitted]…
    else:
                 _logger.error(
                     "Actor %s: Raised an exception while running.",
                     task.get_name(),
-                    exc_info=exception,
+                    exc_info=rest,
                 )
-            else:
-                _logger.info("Actor %s: Finished normally.", task.get_name())
 
     _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

78:            cancelled, rest = _split_cancelled(exception)
80:                _logger.info("Actor %s: Cancelled while running.", task.get_name())

+
+    Exception groups are searched recursively, so a `CancelledError` buried inside
+    an exception group is still recognized as a cancellation.
+
+    Args:
+        exception: The exception to inspect.
+
+    Returns:
+        A tuple with two elements: whether the exception represents a cancellation,
+        and the part of the exception that is not a cancellation (`None` if the
+        exception was only cancellations or the
…[1123 chars omitted]…
(
                     "Actor %s: Raised an exception while running.",
                     task.get_name(),
-                    exc_info=exception,
+                    exc_info=rest,
                 )
-            else:
-                _logger.info("Actor %s: Finished normally.", task.get_name())
 
     _logger.info("All %s actor(s) finished.", len(actors))
 M src/frequenz/sdk/actor/_run_utils.py

+) -> tuple[bool, BaseException | None]:
+    """Split an exception into its cancelled and non-cancelled parts.
+
+    Exception groups are searched recursively, so a `CancelledError` buried inside
+    an exception group is still recognized as a cancellation.
+
+    Args:
+        exception: The exception to inspect.
+
+    Returns:
+        A tuple with two elements: whether the exception represents a cancellation,
…[1213 chars omitted]…
    else:
                 _logger.error(
                     "Actor %s: Raised an exception while running.",
                     task.get_name(),
-                    exc_info=exception,
+                    exc_info=rest,
                 )
-            else:
-                _logger.info("Actor %s: Finished normally.", task.get_name())
 
     _logger.info("All %s actor(s) finished.", len(actors))

+
+    Exception groups are searched recursively, so a `CancelledError` buried inside
+    an exception group is still recognized as a cancellation.
+
+    Args:
+        exception: The exception to inspect.
+
+    Returns:
+        A tuple with two elements: whether the exception represents a cancellation,
+        and the part of the exception that is not a cancellation (`None` if the
+        exception was only cancellations or the
…[1123 chars omitted]…
(
                     "Actor %s: Raised an exception while running.",
                     task.get_name(),
-                    exc_info=exception,
+                    exc_info=rest,
                 )
-            else:
-                _logger.info("Actor %s: Finished normally.", task.get_name())
 
     _logger.info("All %s actor(s) finished.", len(actors))
 M src/frequenz/sdk/actor/_run_utils.py

from ._actor import Actor

_logger = logging.getLogger(__name__)


def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancel
…[1864 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[497 chars omitted]…
 actors properly.

    Args:
        *actors: the actors to be awaited.
    """
    _logger.info("Starting %s actor(s)...", len(actors))

    for actor in actors:
        if actor.is_running:
            _logger.info("Actor %s: Already running, skipping start.", actor)
        else:
            _logger.info("Actor %s: Starting...", actor)
            actor.start()

    # Wait until all actors are done

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))

def _split_cancelled(
    exception: BaseException,
) -> tuple[bool, BaseException | None]:
    """Split an exception into its cancelled and non-cancelled parts.

    Exception groups are searched recursively, so a `CancelledError` buried inside
    an exception group is still recognized as a cancellation.

    Args:
        exception: The exception to inspect.

    Returns:
        A tuple with two elements: whether the exception represents a cancellation,
        and the part of the exception that is not a cancellation (`None` if the
        exception was only cancellations or the exception itself was a
        `CancelledError`).
    """
    if i
…[1728 chars omitted]…
_split_cancelled(exception)
            if cancelled:
                _logger.info("Actor %s: Cancelled while running.", task.get_name())
            else:
                _logger.error(
                    "Actor %s: Raised an exception while running.",
                    task.get_name(),
                    exc_info=rest,
                )

    _logger.info("All %s actor(s) finished.", len(actors))