canvas 0.19.1__py3-none-any.whl → 0.21.0__py3-none-any.whl

canvas_sdk/effects/billing_line_item/__init__.py

@@ -0,0 +1,11 @@
+from canvas_sdk.effects.billing_line_item.add_billing_line_item import (
+    AddBillingLineItem,
+)
+from canvas_sdk.effects.billing_line_item.remove_billing_line_item import (
+    RemoveBillingLineItem,
+)
+from canvas_sdk.effects.billing_line_item.update_billing_line_item import (
+    UpdateBillingLineItem,
+)
+
+__all__ = ("AddBillingLineItem", "UpdateBillingLineItem", "RemoveBillingLineItem")

canvas_sdk/effects/billing_line_item/add_billing_line_item.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+from canvas_sdk.commands.constants import Coding
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class AddBillingLineItem(_BaseEffect):
+    """
+    An Effect that will result in a billing line item in a note footer.
+    """
+
+    class Meta:
+        effect_type = EffectType.ADD_BILLING_LINE_ITEM
+        apply_required_fields = ("note_id", "cpt")
+
+    note_id: str | None = None
+    cpt: str | None = None
+    units: int | None = 1
+    assessment_ids: list[str] = []
+    modifiers: list[Coding] = []
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The BillingLineItem's values."""
+        return {
+            "cpt": self.cpt,
+            "units": self.units,
+            "assessment_ids": self.assessment_ids,
+            "modifiers": self.modifiers,
+        }
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {
+            "note_id": self.note_id,
+            "data": self.values,
+        }

canvas_sdk/effects/billing_line_item/remove_billing_line_item.py

@@ -0,0 +1,22 @@
+from typing import Any
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class RemoveBillingLineItem(_BaseEffect):
+    """
+    An Effect that will remove a billing line item in a note footer.
+    """
+
+    class Meta:
+        effect_type = EffectType.REMOVE_BILLING_LINE_ITEM
+        apply_required_fields = ("billing_line_item_id",)
+
+    billing_line_item_id: str | None = None
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {
+            "billing_line_item_id": self.billing_line_item_id,
+        }

canvas_sdk/effects/billing_line_item/update_billing_line_item.py

@@ -0,0 +1,44 @@
+from typing import Any
+
+from canvas_sdk.commands.constants import Coding
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class UpdateBillingLineItem(_BaseEffect):
+    """
+    An Effect that will update a billing line item in a note footer.
+    """
+
+    class Meta:
+        effect_type = EffectType.UPDATE_BILLING_LINE_ITEM
+        apply_required_fields = ("billing_line_item_id",)
+
+    billing_line_item_id: str | None = None
+    cpt: str | None = None
+    units: int | None = None
+    assessment_ids: list[str] | None = None
+    modifiers: list[Coding] | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The BillingLineItem's values."""
+        values: dict[str, str | int | list] = {}
+        # only include the values where a value has been set so as to not unintentionally override existing values
+        if self.cpt is not None:
+            values["cpt"] = self.cpt
+        if self.units is not None:
+            values["units"] = self.units
+        if self.assessment_ids is not None:
+            values["assessment_ids"] = self.assessment_ids
+        if self.modifiers is not None:
+            values["modifiers"] = self.modifiers
+
+        return values
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {
+            "billing_line_item_id": self.billing_line_item_id,
+            "data": self.values,
+        }

canvas_sdk/effects/launch_modal.py

@@ -16,6 +16,7 @@ class LaunchModalEffect(_BaseEffect):
         DEFAULT_MODAL = "default_modal"
         NEW_WINDOW = "new_window"
         RIGHT_CHART_PANE = "right_chart_pane"
+        RIGHT_CHART_PANE_LARGE = "right_chart_pane_large"
 
     url: str | None = None
     content: str | None = None

canvas_sdk/utils/stats.py

@@ -1,6 +1,9 @@
+from datetime import timedelta
 from time import time
 from typing import Any
 
+from statsd.defaults.env import statsd as default_statsd_client
+
 
 def get_duration_ms(start_time: float) -> int:
     """Get the duration in milliseconds since the given start time."""
@@ -26,3 +29,35 @@ def tags_to_line_protocol(tags: dict[str, Any]) -> str:
         f"{tag_name}={str(tag_value).translate(LINE_PROTOCOL_TRANSLATION)}"
         for tag_name, tag_value in tags.items()
     )
+
+
+class StatsDClientProxy:
+    """Proxy for a StatsD client."""
+
+    def __init__(self) -> None:
+        self.client = default_statsd_client
+
+    def gauge(self, metric_name: str, value: float, tags: dict[str, str]) -> None:
+        """Sends a gauge metric to StatsD with properly formatted tags.
+
+        Args:
+            metric_name (str): The name of the metric.
+            value (float): The value to report.
+            tags (dict[str, str]): Dictionary of tags to attach to the metric.
+        """
+        statsd_tags = tags_to_line_protocol(tags)
+        self.client.gauge(f"{metric_name},{statsd_tags}", value)
+
+    def timing(self, metric_name: str, delta: float | timedelta, tags: dict[str, str]) -> None:
+        """Sends a timing metric to StatsD with properly formatted tags.
+
+        Args:
+            metric_name (str): The name of the metric.
+            delta (float | timedelta): The value to report.
+            tags (dict[str, str]): Dictionary of tags to attach to the metric.
+        """
+        statsd_tags = tags_to_line_protocol(tags)
+        self.client.timing(f"{metric_name},{statsd_tags}", delta)
+
+
+statsd_client = StatsDClientProxy()

canvas_sdk/v1/data/lab.py

@@ -311,3 +311,41 @@ class LabTest(models.Model):
 
     def __str__(self) -> str:
         return f"{self.ontology_test_name}: f{self.ontology_test_code}"
+
+
+class LabPartner(models.Model):
+    """A class representing a lab partner."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_lab_partner_001"
+
+    objects: models.Manager["LabPartner"]
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    name = models.CharField(max_length=256)
+    active = models.BooleanField()
+    electronic_ordering_enabled = models.BooleanField()
+    keywords = models.TextField()
+    default_lab_account_number = models.CharField(max_length=256)
+
+
+class LabPartnerTest(models.Model):
+    """A class representing a lab partner's test."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_lab_partner_test_001"
+
+    objects: models.Manager["LabPartnerTest"]
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    lab_partner = models.ForeignKey(
+        "LabPartner", on_delete=models.DO_NOTHING, related_name="available_tests"
+    )
+    order_code = models.CharField(max_length=256, blank=True)
+    order_name = models.TextField()
+    keywords = models.TextField(blank=True)
+    cpt_code = models.CharField(max_length=256, blank=True, null=True)

canvas_sdk/v1/data/note.py

@@ -90,10 +90,13 @@ class NoteTypes(models.TextChoices):
 class NoteType(models.Model):
     """NoteType."""
 
+    objects: models.Manager["NoteType"]
+
     class Meta:
         managed = False
         db_table = "canvas_sdk_data_api_notetype_001"
 
+    id = models.UUIDField()
     dbid = models.BigIntegerField(primary_key=True)
     created = models.DateTimeField()
     modified = models.DateTimeField()

logger/logger.py

@@ -24,18 +24,25 @@ class PluginLogger:
     def __init__(self) -> None:
         self.logger = logging.getLogger("plugin_runner_logger")
         self.logger.setLevel(logging.INFO)
+
         log_prefix = os.getenv("HOSTNAME", "")
+
         if log_prefix != "":
             log_prefix = f"[{log_prefix}] "
-        formatter = logging.Formatter(f"{log_prefix}%(levelname)s %(asctime)s %(message)s")
+
+        formatter = logging.Formatter(
+            f"plugin_runner {log_prefix}%(levelname)s %(asctime)s %(message)s"
+        )
 
         streaming_handler = logging.StreamHandler()
         streaming_handler.setFormatter(formatter)
+
         self.logger.addHandler(streaming_handler)
 
         if os.getenv("REDIS_ENDPOINT"):
             pubsub_handler = PubSubLogHandler()
             pubsub_handler.setFormatter(formatter)
+
             self.logger.addHandler(pubsub_handler)
 
     def debug(self, message: Any) -> None:

plugin_runner/{plugin_installer.py → installation.py}

@@ -14,6 +14,7 @@ import requests
 from psycopg import Connection
 from psycopg.rows import dict_row
 
+from logger import log
 from plugin_runner.aws_headers import aws_sig_v4_headers
 from plugin_runner.exceptions import InvalidPluginFormat, PluginInstallationError
 from settings import (
@@ -72,8 +73,8 @@ def enabled_plugins() -> dict[str, PluginAttributes]:
 
     with conn.cursor(row_factory=dict_row) as cursor:
         cursor.execute(
-            "select name, package, version, key, value from plugin_io_plugin p "
-            "left join plugin_io_pluginsecret s on p.id = s.plugin_id where is_enabled"
+            "SELECT name, package, version, key, value FROM plugin_io_plugin p "
+            "LEFT JOIN plugin_io_pluginsecret s ON p.id = s.plugin_id WHERE is_enabled"
         )
         rows = cursor.fetchall()
         plugins = _extract_rows_to_dict(rows)
@@ -83,6 +84,7 @@ def enabled_plugins() -> dict[str, PluginAttributes]:
 
 def _extract_rows_to_dict(rows: list) -> dict[str, PluginAttributes]:
     plugins = {}
+
     for row in rows:
         if row["name"] not in plugins:
             plugins[row["name"]] = PluginAttributes(
@@ -92,6 +94,7 @@ def _extract_rows_to_dict(rows: list) -> dict[str, PluginAttributes]:
             )
         else:
             plugins[row["name"]]["secrets"][row["key"]] = row["value"]
+
     return plugins
 
 
@@ -123,16 +126,18 @@ def download_plugin(plugin_package: str) -> Generator[Path, None, None]:
         prefix_dir = Path(temp_dir) / UPLOAD_TO_PREFIX
         prefix_dir.mkdir()  # create an intermediate directory reflecting the prefix
         download_path = Path(temp_dir) / plugin_package
+
         with open(download_path, "wb") as download_file:
             response = requests.request(method=method, url=f"https://{host}{path}", headers=headers)
             download_file.write(response.content)
+
         yield download_path
 
 
 def install_plugin(plugin_name: str, attributes: PluginAttributes) -> None:
     """Install the given Plugin's package into the runtime."""
     try:
-        print(f"Installing plugin '{plugin_name}'")
+        log.info(f'Installing plugin "{plugin_name}"')
 
         plugin_installation_path = Path(PLUGIN_DIRECTORY) / plugin_name
 
@@ -145,12 +150,14 @@ def install_plugin(plugin_name: str, attributes: PluginAttributes) -> None:
 
         install_plugin_secrets(plugin_name=plugin_name, secrets=attributes["secrets"])
     except Exception as ex:
-        print(f"Failed to install plugin '{plugin_name}', version {attributes['version']}")
+        log.error(f'Failed to install plugin "{plugin_name}", version {attributes["version"]}')
         raise PluginInstallationError() from ex
 
 
 def extract_plugin(plugin_file_path: Path, plugin_installation_path: Path) -> None:
     """Extract plugin in `file` to the given `path`."""
+    log.info(f'Extracting plugin at "{plugin_file_path}"')
+
     archive: tarfile.TarFile | None = None
 
     try:
@@ -160,10 +167,10 @@ def extract_plugin(plugin_file_path: Path, plugin_installation_path: Path) -> No
                     archive = tarfile.TarFile.open(fileobj=file)
                     archive.extractall(plugin_installation_path, filter="data")
             except tarfile.ReadError as ex:
-                print(f"Unreadable tar archive: '{plugin_file_path}'")
+                log.error(f"Unreadable tar archive: '{plugin_file_path}'")
                 raise InvalidPluginFormat from ex
         else:
-            print(f"Unsupported file format: '{plugin_file_path}'")
+            log.error(f"Unsupported file format: '{plugin_file_path}'")
             raise InvalidPluginFormat
     finally:
         if archive:
@@ -172,7 +179,7 @@ def extract_plugin(plugin_file_path: Path, plugin_installation_path: Path) -> No
 
 def install_plugin_secrets(plugin_name: str, secrets: dict[str, str]) -> None:
     """Write the plugin's secrets to disk in the package's directory."""
-    print(f"Writing plugin secrets for '{plugin_name}'")
+    log.info(f"Writing plugin secrets for '{plugin_name}'")
 
     secrets_path = Path(PLUGIN_DIRECTORY) / plugin_name / SECRETS_FILE_NAME
 
@@ -188,7 +195,7 @@ def disable_plugin(plugin_name: str) -> None:
     """Disable the given plugin."""
     conn = open_database_connection()
     conn.cursor().execute(
-        "update plugin_io_plugin set is_enabled = false where name = %s", (plugin_name,)
+        "UPDATE plugin_io_plugin SET is_enabled = false WHERE name = %s", (plugin_name,)
     )
     conn.commit()
     conn.close()
@@ -198,6 +205,8 @@ def disable_plugin(plugin_name: str) -> None:
 
 def uninstall_plugin(plugin_name: str) -> None:
     """Remove the plugin from the filesystem."""
+    log.info(f'Uninstalling plugin "{plugin_name}"')
+
     plugin_path = Path(PLUGIN_DIRECTORY) / plugin_name
 
     if plugin_path.exists():
@@ -206,6 +215,8 @@ def uninstall_plugin(plugin_name: str) -> None:
 
 def install_plugins() -> None:
     """Install all enabled plugins."""
+    log.info("Installing plugins")
+
     if Path(PLUGIN_DIRECTORY).exists():
         shutil.rmtree(PLUGIN_DIRECTORY)
 
@@ -213,12 +224,13 @@ def install_plugins() -> None:
 
     for plugin_name, attributes in enabled_plugins().items():
         try:
-            print(f"Installing plugin '{plugin_name}', version {attributes['version']}")
+            log.info(f'Installing plugin "{plugin_name}", version {attributes["version"]}')
             install_plugin(plugin_name, attributes)
         except PluginInstallationError:
             disable_plugin(plugin_name)
-            print(
-                f"Installation failed for plugin '{plugin_name}', version {attributes['version']}. The plugin has been disabled"
+            log.error(
+                f'Installation failed for plugin "{plugin_name}", version {attributes["version"]};'
+                " the plugin has been disabled"
             )
             continue
 

plugin_runner/plugin_runner.py

@@ -13,13 +13,9 @@ from typing import Any, TypedDict
 
 import grpc
 import redis.asyncio as redis
-import statsd
 
 from canvas_generated.messages.effects_pb2 import EffectType
-from canvas_generated.messages.plugins_pb2 import (
-    ReloadPluginsRequest,
-    ReloadPluginsResponse,
-)
+from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest, ReloadPluginsResponse
 from canvas_generated.services.plugin_runner_pb2_grpc import (
     PluginRunnerServicer,
     add_PluginRunnerServicer_to_server,
@@ -27,10 +23,10 @@ from canvas_generated.services.plugin_runner_pb2_grpc import (
 from canvas_sdk.effects import Effect
 from canvas_sdk.events import Event, EventRequest, EventResponse, EventType
 from canvas_sdk.protocols import ClinicalQualityMeasure
-from canvas_sdk.utils.stats import get_duration_ms, tags_to_line_protocol
+from canvas_sdk.utils.stats import get_duration_ms, statsd_client
 from logger import log
 from plugin_runner.authentication import token_for_plugin
-from plugin_runner.plugin_installer import install_plugins
+from plugin_runner.installation import install_plugins
 from plugin_runner.sandbox import Sandbox
 from settings import (
     CHANNEL_NAME,
@@ -110,10 +106,6 @@ class PluginManifest(TypedDict):
 class PluginRunner(PluginRunnerServicer):
     """This process runs provided plugins that register interest in incoming events."""
 
-    def __init__(self) -> None:
-        self.statsd_client = statsd.StatsClient()
-        super().__init__()
-
     sandbox: Sandbox
 
     async def HandleEvent(
@@ -168,10 +160,10 @@ class PluginRunner(PluginRunnerServicer):
                 compute_duration = get_duration_ms(compute_start_time)
 
                 log.info(f"{plugin_name}.compute() completed ({compute_duration} ms)")
-                statsd_tags = tags_to_line_protocol({"plugin": plugin_name})
-                self.statsd_client.timing(
-                    f"plugins.protocol_duration_ms,{statsd_tags}",
+                statsd_client.timing(
+                    "plugins.protocol_duration_ms",
                     delta=compute_duration,
+                    tags={"plugin": plugin_name},
                 )
             except Exception as e:
                 for error_line_with_newlines in traceback.format_exception(e):
@@ -186,10 +178,8 @@ class PluginRunner(PluginRunnerServicer):
         # Don't log anything if a plugin handler didn't actually run.
         if relevant_plugins:
             log.info(f"Responded to Event {event_name} ({event_duration} ms)")
-            statsd_tags = tags_to_line_protocol({"event": event_name})
-            self.statsd_client.timing(
-                f"plugins.event_duration_ms,{statsd_tags}",
-                delta=event_duration,
+            statsd_client.timing(
+                "plugins.event_duration_ms", delta=event_duration, tags={"event": event_name}
             )
 
         yield EventResponse(success=True, effects=effect_list)
@@ -207,19 +197,21 @@ class PluginRunner(PluginRunnerServicer):
             yield ReloadPluginsResponse(success=True)
 
 
-async def synchronize_plugins(max_iterations: None | int = None) -> None:
-    """Listen for messages on the pubsub channel that will indicate it is necessary to reinstall and reload plugins."""
+async def synchronize_plugins(run_once: bool = False) -> None:
+    """
+    Listen for messages on the pubsub channel that will indicate it is
+    necessary to reinstall and reload plugins.
+    """
+    log.info(f'synchronize_plugins: listening for messages on pubsub channel "{CHANNEL_NAME}"')
+
     client, pubsub = get_client()
     await pubsub.psubscribe(CHANNEL_NAME)
-    log.info("Listening for messages on pubsub channel")
-    iterations: int = 0
-    while (
-        max_iterations is None or iterations < max_iterations
-    ):  # max_iterations == -1 means infinite iterations
-        iterations += 1
+
+    while True:
         message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=None)
+
         if message is not None:
-            log.info("Received message from pubsub channel")
+            log.info(f'synchronize_plugins: received message from pubsub channel "{CHANNEL_NAME}"')
 
             message_type = message.get("type", "")
 
@@ -232,19 +224,44 @@ async def synchronize_plugins(max_iterations: None | int = None) -> None:
                 continue
 
             if data["action"] == "reload":
+                log.info("synchronize_plugins: installing and reloading plugins for action=reload")
+
                 try:
-                    log.info(
-                        "plugin-synchronizer: installing and reloading plugins after receiving command"
-                    )
                     install_plugins()
+                except Exception as e:
+                    # TODO capture_exception when Sentry is installed
+                    log.error(f"synchronize_plugins: install_plugins failed: {e}")
+
+                try:
                     load_plugins()
                 except Exception as e:
-                    print("plugin-synchronizer: `install_plugins` failed:", e)
+                    # TODO capture_exception when Sentry is installed
+                    log.error(f"synchronize_plugins: load_plugins failed: {e}")
+        if run_once:
+            break
+
+
+async def synchronize_plugins_and_report_errors() -> None:
+    """
+    Run synchronize_plugins() in perpetuity and report any encountered errors.
+    """
+    log.info("Starting synchronize_plugins loop...")
+
+    while True:
+        try:
+            await synchronize_plugins()
+        except Exception as e:
+            log.error(f"synchronize_plugins error: {e}")
+
+        # don't crush redis if we're retrying in a tight loop
+        await asyncio.sleep(0.5)
 
 
 def validate_effects(effects: list[Effect]) -> list[Effect]:
     """Validates the effects based on predefined rules.
-    Keeps only the first AUTOCOMPLETE_SEARCH_RESULTS effect and preserve all non-search-related effects.
+
+    Keeps only the first AUTOCOMPLETE_SEARCH_RESULTS effect and preserve all
+    non-search-related effects.
     """
     seen_autocomplete = False
     validated_effects = []
@@ -254,7 +271,9 @@ def validate_effects(effects: list[Effect]) -> list[Effect]:
             if seen_autocomplete:
                 log.warning("Discarding additional AUTOCOMPLETE_SEARCH_RESULTS effect.")
                 continue
+
             seen_autocomplete = True
+
         validated_effects.append(effect)
 
     return validated_effects
@@ -311,7 +330,7 @@ def sandbox_from_module(base_path: pathlib.Path, module_name: str) -> Any:
 
 async def publish_message(message: dict) -> None:
     """Publish a message to the pubsub channel."""
-    log.info("Publishing message to pubsub channel")
+    log.info(f'Publishing message to pubsub channel "{CHANNEL_NAME}"')
     client, _ = get_client()
 
     await client.publish(CHANNEL_NAME, pickle.dumps(message))
@@ -327,7 +346,7 @@ def get_client() -> tuple[redis.Redis, redis.client.PubSub]:
 
 def load_or_reload_plugin(path: pathlib.Path) -> None:
     """Given a path, load or reload a plugin."""
-    log.info(f"Loading {path}")
+    log.info(f'Loading plugin at "{path}"')
 
     manifest_file = path / MANIFEST_FILE_NAME
     manifest_json_str = manifest_file.read_text()
@@ -366,7 +385,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
             handler_module, handler_class = handler["class"].split(":")
             name_and_class = f"{name}:{handler_module}:{handler_class}"
         except ValueError:
-            log.error(f"Unable to parse class for plugin '{name}': '{handler['class']}'")
+            log.error(f'Unable to parse class for plugin "{name}": "{handler["class"]}"')
             continue
 
         try:
@@ -391,7 +410,8 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
                     "secrets": secrets_json,
                 }
         except Exception as err:
-            log.error(f"Error importing module '{name_and_class}': {err}")
+            log.error(f'Error importing module "{name_and_class}": {err}')
+
             for error_line in traceback.format_exception(err):
                 log.error(error_line)
 
@@ -438,9 +458,6 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
     # get all directories under the plugin directory
     plugin_paths = [path for path in plugin_paths if path.is_dir()]
 
-    # filter to only the directories containing a manifest file
-    plugin_paths = [path for path in plugin_paths if (path / MANIFEST_FILE_NAME).exists()]
-
     # load or reload each plugin
     for plugin_path in plugin_paths:
         load_or_reload_plugin(plugin_path)
@@ -452,6 +469,15 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
 
     refresh_event_type_map()
 
+    log_nr_event_handlers()
+
+
+def log_nr_event_handlers() -> None:
+    """Log the number of event handlers for each event."""
+    for key in EventType.keys():  # noqa: SIM118
+        value = len(EVENT_HANDLER_MAP[key]) if key in EVENT_HANDLER_MAP else 0
+        statsd_client.timing("plugins.event_nr_handlers", value, tags={"event": key})
+
 
 _cleanup_coroutines = []
 
@@ -481,6 +507,7 @@ async def serve(specified_plugin_paths: list[str] | None = None) -> None:
     await server.wait_for_termination()
 
 
+# NOTE: specified_plugin_paths powers the `canvas run-plugins` command
 def run_server(specified_plugin_paths: list[str] | None = None) -> None:
     """Run the server."""
     loop = asyncio.new_event_loop()
@@ -489,7 +516,10 @@ def run_server(specified_plugin_paths: list[str] | None = None) -> None:
 
     try:
         loop.run_until_complete(
-            asyncio.gather(serve(specified_plugin_paths), synchronize_plugins())
+            asyncio.gather(
+                serve(specified_plugin_paths),
+                synchronize_plugins_and_report_errors(),
+            )
         )
     except KeyboardInterrupt:
         pass

plugin_runner/tests/test_plugin_installer.py

@@ -6,7 +6,7 @@ from unittest.mock import MagicMock, patch
 
 from pytest_mock import MockerFixture
 
-from plugin_runner.plugin_installer import (
+from plugin_runner.installation import (
     PluginAttributes,
     _extract_rows_to_dict,
     download_plugin,
@@ -82,7 +82,7 @@ def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
     tarball_1 = _create_tarball("plugin1")
     tarball_2 = _create_tarball("plugin2")
 
-    mocker.patch("plugin_runner.plugin_installer.enabled_plugins", return_value=mock_plugins)
+    mocker.patch("plugin_runner.installation.enabled_plugins", return_value=mock_plugins)
 
     def mock_download_plugin(package: str) -> MagicMock:
         mock_context = mocker.Mock()
@@ -94,7 +94,7 @@ def test_plugin_installation_from_tarball(mocker: MockerFixture) -> None:
         return mock_context
 
     mocker.patch(
-        "plugin_runner.plugin_installer.download_plugin",
+        "plugin_runner.installation.download_plugin",
         side_effect=mock_download_plugin,
     )
 

plugin_runner/tests/test_plugin_runner.py

@@ -271,7 +271,7 @@ async def test_synchronize_plugins_calls_install_and_load_plugins() -> None:
             "data": pickle.dumps({"action": "reload"}),
         }
 
-        task = asyncio.create_task(synchronize_plugins(max_iterations=1))
+        task = asyncio.create_task(synchronize_plugins(run_once=True))
         await asyncio.sleep(0.1)  # Give some time for the coroutine to run
         task.cancel()