Remove actor decorator

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

src/frequenz/sdk/actor/__init__.py

@@ -9,7 +9,6 @@
 from ._channel_registry import ChannelRegistry
 from ._config_managing import ConfigManagingActor
 from ._data_sourcing import ComponentMetricRequest, DataSourcingActor
-from ._decorator import actor
 from ._resampling import ComponentMetricsResamplingActor
 from ._run_utils import run
 
@@ -22,6 +21,5 @@
     "ConfigManagingActor",
     "DataSourcingActor",
     "ResamplerConfig",
-    "actor",
     "run",
 ]

src/frequenz/sdk/actor/_decorator.py

@@ -6,39 +6,39 @@
 
 import asyncio
 import logging
-from typing import Any
 
 from ._actor import Actor
-from ._decorator import BaseActor
 
 _logger = logging.getLogger(__name__)
 
 
-async def run(*actors: Any) -> None:
+async def run(*actors: Actor) -> None:
     """Await the completion of all actors.
 
     Args:
         actors: the actors to be awaited.
-
-    Raises:
-        AssertionError: if any of the actors is not an instance of BaseActor.
     """
-    pending_tasks: set[asyncio.Task[Any]] = set()
-
-    # Check that each actor is an instance of BaseActor or Actor at runtime,
-    # due to the indirection created by the actor decorator.
-    for actor in actors:
-        if isinstance(actor, Actor):
-            await actor.start()
-            awaitable = actor.wait()
-        else:
-            assert isinstance(
-                actor, BaseActor
-            ), f"{actor} is not an instance of BaseActor or Actor"
-            awaitable = actor.join()  # type: ignore
-        pending_tasks.add(asyncio.create_task(awaitable, name=str(actor)))
-
-    # Currently the actor decorator manages the life-cycle of the actor tasks
+    _logger.info("Starting %s actor(s)...", len(actors))
+    await _wait_tasks(
+        set(asyncio.create_task(a.start(), name=str(a)) for a in actors),
+        "starting",
+        "started",
+    )
+
+    # Wait until all actors are done
+    await _wait_tasks(
+        set(asyncio.create_task(a.wait(), name=str(a)) for a in actors),
+        "running",
+        "finished",
+    )
+
+    _logger.info("All %s actor(s) finished.", len(actors))
+
+
+async def _wait_tasks(
+    tasks: set[asyncio.Task[None]], error_str: str, success_str: str
+) -> None:
+    pending_tasks = tasks
     while pending_tasks:
         done_tasks, pending_tasks = await asyncio.wait(
             pending_tasks, return_when=asyncio.FIRST_COMPLETED
@@ -49,12 +49,19 @@ async def run(*actors: Any) -> None:
             # Cancellation needs to be checked first, otherwise the other methods
             # could raise a CancelledError
             if task.cancelled():
-                _logger.info("The actor %s was cancelled", task.get_name())
+                _logger.info(
+                    "Actor %s: Cancelled while %s.",
+                    task.get_name(),
+                    error_str,
+                )
             elif exception := task.exception():
                 _logger.error(
-                    "The actor %s was finished due to an uncaught exception",
+                    "Actor %s: Raised an exception while %s.",
                     task.get_name(),
+                    error_str,
                     exc_info=exception,
                 )
             else:
-                _logger.info("The actor %s finished normally", task.get_name())
+                _logger.info(
+                    "Actor %s: %s normally.", task.get_name(), success_str.capitalize()
+                )

src/frequenz/sdk/actor/_run_utils.py

@@ -4,7 +4,7 @@
 """Setup for all the tests."""
 import pytest
 
-from frequenz.sdk.actor import _actor, _decorator
+from frequenz.sdk.actor import _actor
 
 # Used to impose a hard time limit for some async tasks in tests so that tests don't
 # run forever in case of a bug
@@ -23,5 +23,4 @@ def disable_actor_auto_restart():  # type: ignore
     Note: Test class must derive after unittest.IsolatedAsyncioTestCase.
     Otherwise this fixture won't run.
     """
-    _decorator.BaseActor.restart_limit = 0
     _actor.Actor._restart_limit = 0  # pylint: disable=protected-access